1999-04-16 03:35:26 +02:00
|
|
|
/* Definitions for dealing with stack frames, for GDB, the GNU debugger.
|
2002-04-11 00:14:02 +02:00
|
|
|
|
|
|
|
Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996,
|
2003-01-05 02:39:56 +01:00
|
|
|
1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
This file is part of GDB.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
Boston, MA 02111-1307, USA. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
#if !defined (FRAME_H)
|
|
|
|
#define FRAME_H 1
|
|
|
|
|
2003-06-21 18:26:02 +02:00
|
|
|
/* The following is the intended naming schema for frame functions.
|
|
|
|
It isn't 100% consistent, but it is aproaching that. Frame naming
|
|
|
|
schema:
|
|
|
|
|
|
|
|
Prefixes:
|
|
|
|
|
|
|
|
get_frame_WHAT...(): Get WHAT from the THIS frame (functionaly
|
|
|
|
equivalent to THIS->next->unwind->what)
|
|
|
|
|
|
|
|
frame_unwind_WHAT...(): Unwind THIS frame's WHAT from the NEXT
|
|
|
|
frame.
|
|
|
|
|
|
|
|
put_frame_WHAT...(): Put a value into this frame (unsafe, need to
|
|
|
|
invalidate the frame / regcache afterwards) (better name more
|
|
|
|
strongly hinting at its unsafeness)
|
|
|
|
|
|
|
|
safe_....(): Safer version of various functions, doesn't throw an
|
|
|
|
error (leave this for later?). Returns non-zero if the fetch
|
|
|
|
succeeds. Return a freshly allocated error message?
|
|
|
|
|
|
|
|
Suffixes:
|
|
|
|
|
|
|
|
void /frame/_WHAT(): Read WHAT's value into the buffer parameter.
|
|
|
|
|
|
|
|
ULONGEST /frame/_WHAT_unsigned(): Return an unsigned value (the
|
|
|
|
alternative is *frame_unsigned_WHAT).
|
|
|
|
|
|
|
|
LONGEST /frame/_WHAT_signed(): Return WHAT signed value.
|
|
|
|
|
|
|
|
What:
|
|
|
|
|
|
|
|
/frame/_memory* (frame, coreaddr, len [, buf]): Extract/return
|
|
|
|
*memory.
|
|
|
|
|
|
|
|
/frame/_register* (frame, regnum [, buf]): extract/return register.
|
|
|
|
|
|
|
|
CORE_ADDR /frame/_{pc,sp,...} (frame): Resume address, innner most
|
|
|
|
stack *address, ...
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2002-11-29 02:52:02 +01:00
|
|
|
struct symtab_and_line;
|
2003-01-18 Andrew Cagney <ac131313@redhat.com>
* dummy-frame.h (dummy_frame_id_unwind): Delete declaration.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
(struct frame_unwind): Declare opaque.
(dummy_frame_p): Declare function.
* dummy-frame.c (dummy_frame_id_unwind): Make static.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
* dummy-frame.c: Include "frame-unwind.h".
(dummy_frame_p): New function.
(dummy_frame_unwind): New variable.
* frame.c: Include "frame-unwind.h".
(frame_pc_unwind, frame_id_unwind, frame_register_unwind): Update
to use the new unwind field.
(set_unwind_by_pc): Delete function.
(create_new_frame, get_prev_frame): Set unwind field using
frame_unwind_find_by_pc.
(trad_frame_unwind, trad_frame_unwinder): New variables.
* frame.h (trad_frame_unwind): Declare variable.
(frame_id_unwind_ftype): Delete declaration.
(frame_pc_unwind_ftype, frame_register_unwind_ftype): Ditto.
(struct frame_unwind): Declare opaque.
(struct frame_info): Replace the fields id_unwind, pc_unwind and
register_unwind with a single unwind pointer.
* frame-unwind.h, frame-unwind.c: New files.
* Makefile.in (SFILES): Add frame-unwind.c.
(frame_unwind_h): Define.
(COMMON_OBS): Add frame-unwind.o.
(frame-unwind.o): Specify dependencies.
(frame.o, dummy-frame.o): Update dependencies.
2003-01-18 18:25:23 +01:00
|
|
|
struct frame_unwind;
|
2003-04-01 21:11:01 +02:00
|
|
|
struct frame_base;
|
2003-02-19 David Carlton <carlton@math.stanford.edu>
* Makefile.in (SFILES): Add block.c.
(block_h): New.
(COMMON_OBS): Add block.o.
(block.o): New.
(x86-64-tdep.o): Add $(block_h).
(values.o, valops.o, tracepoint.o, symtab.o, symmisc.o, symfile.o)
(stack.o, printcmd.o, p-exp.tab.o, parse.o, objfiles.o)
(objc-exp.tab.o, objc-lang.o, nlmread.o, mips-tdep.o, mdebugread.o)
(m2-exp.tab.o, linespec.o, jv-lang.o, jv-exp.tab.o, infcmd.o)
(f-valprint.o, findvar.o, f-exp.tab.o, expprint.o, coffread.o)
(c-exp.tab.o, buildsym.o, breakpoint.o, blockframe.o, ax-gdb.o)
(alpha-tdep.o, ada-lang.o, ada-exp.tab.o, mi-cmd-stack.o): Ditto.
* value.h: Add opaque declaration for struct block.
* parser-defs.h, objc-lang.h, buildsym.h, breakpoint.h: Ditto.
* ada-lang.h: Ditto.
* x86-64-tdep.c: #include "block.h"
* values.c, valops.c, tracepoint.c, symtab.c, symmisc.c: Ditto.
* symfile.c, stack.c, printcmd.c, p-exp.y, parse.c: Ditto.
* objfiles.c, objc-exp.y, objc-lang.c, nlmread.c: Ditto.
* mips-tdep.c, mdebugread.c, m2-exp.y, linespec.c: Ditto.
* jv-lang.c, jv-exp.y, infcmd.c, f-valprint.c: Ditto.
* findvar.c, f-exp.y, expprint.c, coffread.c, c-exp.y: Ditto.
* buildsym.c, breakpoint.c, blockframe.c, ax-gdb.c: Ditto.
* alpha-tdep.c, ada-lang.c, ada-exp.y: Ditto.
* blockframe.c (blockvector_for_pc_sect): Move to "block.c".
(blockvector_for_pc, block_for_pc_sect, block_for_pc): Ditto.
* symtab.c (block_function): Ditto.
(contained_in): Ditto.
* frame.h: Move block_for_pc and block_for_pc_sect declarations to
block.h. Add opaque declaration for struct block.
* symtab.h: Move block_function and contained_in declarations to
block.h. Add opaque declarations for struct block, struct
blockvector.
(struct block): Move to block.h.
(struct blockvector): Ditto.
(BLOCK_START, BLOCK_END, BLOCK_FUNCTION, BLOCK_SUPERBLOCK)
(BLOCK_GCC_COMPILED, BLOCK_HASHTABLE, BLOCK_NSYMS, BLOCK_SYM)
(BLOCK_BUCKETS, BLOCK_BUCKET, BLOCK_HASHTABLE_SIZE)
(ALL_BLOCK_SYMBOLS, BLOCK_SHOULD_SORT, BLOCKVECTOR_NBLOCKS)
(BLOCKVECTOR_BLOCK, GLOBAL_BLOCK, STATIC_BLOCK, FIRST_LOCAL_BLOCK):
Ditto.
* block.c: New file.
* block.h: New file.
2003-02-19 David Carlton <carlton@math.stanford.edu>
* mi-cmd-stack.c: #include "block.h"
2003-02-20 01:01:07 +01:00
|
|
|
struct block;
|
2003-04-09 23:53:28 +02:00
|
|
|
struct gdbarch;
|
2003-05-12 02:26:19 +02:00
|
|
|
struct ui_file;
|
2003-01-18 Andrew Cagney <ac131313@redhat.com>
* dummy-frame.h (dummy_frame_id_unwind): Delete declaration.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
(struct frame_unwind): Declare opaque.
(dummy_frame_p): Declare function.
* dummy-frame.c (dummy_frame_id_unwind): Make static.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
* dummy-frame.c: Include "frame-unwind.h".
(dummy_frame_p): New function.
(dummy_frame_unwind): New variable.
* frame.c: Include "frame-unwind.h".
(frame_pc_unwind, frame_id_unwind, frame_register_unwind): Update
to use the new unwind field.
(set_unwind_by_pc): Delete function.
(create_new_frame, get_prev_frame): Set unwind field using
frame_unwind_find_by_pc.
(trad_frame_unwind, trad_frame_unwinder): New variables.
* frame.h (trad_frame_unwind): Declare variable.
(frame_id_unwind_ftype): Delete declaration.
(frame_pc_unwind_ftype, frame_register_unwind_ftype): Ditto.
(struct frame_unwind): Declare opaque.
(struct frame_info): Replace the fields id_unwind, pc_unwind and
register_unwind with a single unwind pointer.
* frame-unwind.h, frame-unwind.c: New files.
* Makefile.in (SFILES): Add frame-unwind.c.
(frame_unwind_h): Define.
(COMMON_OBS): Add frame-unwind.o.
(frame-unwind.o): Specify dependencies.
(frame.o, dummy-frame.o): Update dependencies.
2003-01-18 18:25:23 +01:00
|
|
|
|
2003-03-17 15:23:50 +01:00
|
|
|
/* A legacy unwinder to prop up architectures using the old style
|
|
|
|
saved regs array. */
|
|
|
|
extern const struct frame_unwind *legacy_saved_regs_unwind;
|
2002-11-29 02:52:02 +01:00
|
|
|
|
2002-11-15 16:50:21 +01:00
|
|
|
/* The frame object. */
|
|
|
|
|
|
|
|
struct frame_info;
|
|
|
|
|
|
|
|
/* The frame object's ID. This provides a per-frame unique identifier
|
|
|
|
that can be used to relocate a `struct frame_info' after a target
|
2002-12-04 01:05:54 +01:00
|
|
|
resume or a frame cache destruct. It of course assumes that the
|
|
|
|
inferior hasn't unwound the stack past that frame. */
|
2002-11-15 16:50:21 +01:00
|
|
|
|
|
|
|
struct frame_id
|
|
|
|
{
|
2003-04-10 05:30:36 +02:00
|
|
|
/* The frame's stack address. This shall be constant through out
|
|
|
|
the lifetime of a frame. Note that this requirement applies to
|
|
|
|
not just the function body, but also the prologue and (in theory
|
|
|
|
at least) the epilogue. Since that value needs to fall either on
|
|
|
|
the boundary, or within the frame's address range, the frame's
|
|
|
|
outer-most address (the inner-most address of the previous frame)
|
|
|
|
is used. Watch out for all the legacy targets that still use the
|
|
|
|
function pointer register or stack pointer register. They are
|
|
|
|
wrong. */
|
|
|
|
CORE_ADDR stack_addr;
|
|
|
|
/* The frame's code address. This shall be constant through out the
|
|
|
|
lifetime of the frame. While the PC (a.k.a. resume address)
|
|
|
|
changes as the function is executed, this code address cannot.
|
|
|
|
Typically, it is set to the address of the entry point of the
|
|
|
|
frame's function (as returned by frame_func_unwind(). */
|
|
|
|
CORE_ADDR code_addr;
|
2003-10-17 18:32:17 +02:00
|
|
|
/* The frame's special address. This shall be constant through out the
|
|
|
|
lifetime of the frame. This is used for architectures that may have
|
|
|
|
frames that do not change the stack but are still distinct and have
|
|
|
|
some form of distinct identifier (e.g. the ia64 which uses a 2nd
|
|
|
|
stack for registers). This field is treated as unordered - i.e. will
|
|
|
|
not be used in frame ordering comparisons such as frame_id_inner().
|
|
|
|
A zero in this field will be treated as a wild-card when comparing
|
|
|
|
frames for equality. */
|
|
|
|
CORE_ADDR special_addr;
|
2002-11-15 16:50:21 +01:00
|
|
|
};
|
|
|
|
|
2002-12-04 01:05:54 +01:00
|
|
|
/* Methods for constructing and comparing Frame IDs.
|
|
|
|
|
2003-10-17 18:32:17 +02:00
|
|
|
NOTE: Given stackless functions A and B, where A calls B (and hence
|
2002-12-04 01:05:54 +01:00
|
|
|
B is inner-to A). The relationships: !eq(A,B); !eq(B,A);
|
2003-10-17 18:32:17 +02:00
|
|
|
!inner(A,B); !inner(B,A); all hold.
|
|
|
|
|
|
|
|
This is because, while B is inner-to A, B is not strictly inner-to A.
|
|
|
|
Being stackless, they have an identical .stack_addr value, and differ
|
|
|
|
only by their unordered .code_addr and/or .special_addr values.
|
|
|
|
|
|
|
|
Because frame_id_inner is only used as a safety net (e.g.,
|
|
|
|
detect a corrupt stack) the lack of strictness is not a problem.
|
|
|
|
Code needing to determine an exact relationship between two frames
|
|
|
|
must instead use frame_id_eq and frame_id_unwind. For instance,
|
|
|
|
in the above, to determine that A stepped-into B, the equation
|
|
|
|
"A.id != B.id && A.id == id_unwind (B)" can be used. */
|
2002-12-04 01:05:54 +01:00
|
|
|
|
|
|
|
/* For convenience. All fields are zero. */
|
|
|
|
extern const struct frame_id null_frame_id;
|
|
|
|
|
2003-04-10 05:30:36 +02:00
|
|
|
/* Construct a frame ID. The first parameter is the frame's constant
|
|
|
|
stack address (typically the outer-bound), and the second the
|
|
|
|
frame's constant code address (typically the entry point) (or zero,
|
2003-10-17 18:32:17 +02:00
|
|
|
to indicate a wild card). The special identifier address is
|
|
|
|
defaulted to zero. */
|
2003-04-10 05:30:36 +02:00
|
|
|
extern struct frame_id frame_id_build (CORE_ADDR stack_addr,
|
|
|
|
CORE_ADDR code_addr);
|
2002-12-04 01:05:54 +01:00
|
|
|
|
2003-10-17 18:32:17 +02:00
|
|
|
/* Construct a special frame ID. The first parameter is the frame's constant
|
|
|
|
stack address (typically the outer-bound), the second is the
|
|
|
|
frame's constant code address (typically the entry point) (or zero,
|
|
|
|
to indicate a wild card), and the third parameter is the frame's
|
|
|
|
special identifier address (or zero to indicate a wild card or
|
|
|
|
unused default). */
|
|
|
|
extern struct frame_id frame_id_build_special (CORE_ADDR stack_addr,
|
|
|
|
CORE_ADDR code_addr,
|
|
|
|
CORE_ADDR special_addr);
|
|
|
|
|
2002-12-04 01:05:54 +01:00
|
|
|
/* Returns non-zero when L is a valid frame (a valid frame has a
|
|
|
|
non-zero .base). */
|
|
|
|
extern int frame_id_p (struct frame_id l);
|
|
|
|
|
|
|
|
/* Returns non-zero when L and R identify the same frame, or, if
|
|
|
|
either L or R have a zero .func, then the same frame base. */
|
|
|
|
extern int frame_id_eq (struct frame_id l, struct frame_id r);
|
|
|
|
|
|
|
|
/* Returns non-zero when L is strictly inner-than R (they have
|
|
|
|
different frame .bases). Neither L, nor R can be `null'. See note
|
|
|
|
above about frameless functions. */
|
|
|
|
extern int frame_id_inner (struct frame_id l, struct frame_id r);
|
|
|
|
|
2003-05-05 20:33:11 +02:00
|
|
|
/* Write the internal representation of a frame ID on the specified
|
|
|
|
stream. */
|
|
|
|
extern void fprint_frame_id (struct ui_file *file, struct frame_id id);
|
|
|
|
|
2002-12-04 01:05:54 +01:00
|
|
|
|
2002-11-15 16:50:21 +01:00
|
|
|
/* For every stopped thread, GDB tracks two frames: current and
|
|
|
|
selected. Current frame is the inner most frame of the selected
|
2002-11-28 18:11:41 +01:00
|
|
|
thread. Selected frame is the one being examined by the the GDB
|
|
|
|
CLI (selected using `up', `down', ...). The frames are created
|
|
|
|
on-demand (via get_prev_frame()) and then held in a frame cache. */
|
|
|
|
/* FIXME: cagney/2002-11-28: Er, there is a lie here. If you do the
|
|
|
|
sequence: `thread 1; up; thread 2; thread 1' you loose thread 1's
|
|
|
|
selected frame. At present GDB only tracks the selected frame of
|
|
|
|
the current thread. But be warned, that might change. */
|
2002-11-15 16:50:21 +01:00
|
|
|
/* FIXME: cagney/2002-11-14: At any time, only one thread's selected
|
|
|
|
and current frame can be active. Switching threads causes gdb to
|
|
|
|
discard all that cached frame information. Ulgh! Instead, current
|
|
|
|
and selected frame should be bound to a thread. */
|
|
|
|
|
2002-11-28 18:11:41 +01:00
|
|
|
/* On demand, create the inner most frame using information found in
|
|
|
|
the inferior. If the inner most frame can't be created, throw an
|
|
|
|
error. */
|
2002-11-15 16:50:21 +01:00
|
|
|
extern struct frame_info *get_current_frame (void);
|
|
|
|
|
2002-11-28 18:11:41 +01:00
|
|
|
/* Invalidates the frame cache (this function should have been called
|
|
|
|
invalidate_cached_frames).
|
|
|
|
|
|
|
|
FIXME: cagney/2002-11-28: The only difference between
|
|
|
|
flush_cached_frames() and reinit_frame_cache() is that the latter
|
|
|
|
explicitly sets the selected frame back to the current frame there
|
|
|
|
isn't any real difference (except that one delays the selection of
|
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* stack.c (selected_frame, select_frame): Move from here ...
* frame.c (selected_frame, select_frame): ... to here. Include
"language.h".
* Makefile.in (frame.o): Update dependencies.
* frame.c (get_selected_frame): New function.
* frame.h (get_selected_frame): Declare.
(deprecated_selected_frame): Rename selected_frame.
* ada-lang.c, ada-tasks.c, breakpoint.c, corelow.c: Update.
* eval.c, f-valprint.c, findvar.c, frame.c, frame.h: Update.
* h8300-tdep.c, h8500-tdep.c, hppa-tdep.c, infcmd.c: Update.
* inflow.c, infrun.c, macroscope.c, mips-tdep.c: Update.
* mn10300-tdep.c, ocd.c, regcache.h, remote-e7000.c: Update.
* remote-mips.c, remote-rdp.c, sh-tdep.c, sparc-tdep.c: Update.
* stack.c, thread.c, tracepoint.c, valops.c, varobj.c: Update.
* z8k-tdep.c, cli/cli-cmds.c: Update.
Index: mi/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* mi/mi-cmd-stack.c, mi/mi-main.c: Update to use
deprecated_selected_frame.
Index: tui/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* tui/tui-hooks.c: Update to use deprecated_selected_frame.
* tui/tui.c, tui/tuiDisassem.c, tui/tuiRegs.c: Ditto.
* tui/tuiSource.c, tui/tuiSourceWin.c, tui/tuiWin.c: Ditto.
2002-11-29 20:15:16 +01:00
|
|
|
a new frame). Code can instead simply rely on get_selected_frame()
|
|
|
|
to reinit's the selected frame as needed. As for invalidating the
|
|
|
|
cache, there should be two methods one that reverts the thread's
|
|
|
|
selected frame back to current frame (for when the inferior
|
|
|
|
resumes) and one that does not (for when the user modifies the
|
|
|
|
target invalidating the frame cache). */
|
2002-11-15 16:50:21 +01:00
|
|
|
extern void flush_cached_frames (void);
|
|
|
|
extern void reinit_frame_cache (void);
|
|
|
|
|
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* stack.c (selected_frame, select_frame): Move from here ...
* frame.c (selected_frame, select_frame): ... to here. Include
"language.h".
* Makefile.in (frame.o): Update dependencies.
* frame.c (get_selected_frame): New function.
* frame.h (get_selected_frame): Declare.
(deprecated_selected_frame): Rename selected_frame.
* ada-lang.c, ada-tasks.c, breakpoint.c, corelow.c: Update.
* eval.c, f-valprint.c, findvar.c, frame.c, frame.h: Update.
* h8300-tdep.c, h8500-tdep.c, hppa-tdep.c, infcmd.c: Update.
* inflow.c, infrun.c, macroscope.c, mips-tdep.c: Update.
* mn10300-tdep.c, ocd.c, regcache.h, remote-e7000.c: Update.
* remote-mips.c, remote-rdp.c, sh-tdep.c, sparc-tdep.c: Update.
* stack.c, thread.c, tracepoint.c, valops.c, varobj.c: Update.
* z8k-tdep.c, cli/cli-cmds.c: Update.
Index: mi/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* mi/mi-cmd-stack.c, mi/mi-main.c: Update to use
deprecated_selected_frame.
Index: tui/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* tui/tui-hooks.c: Update to use deprecated_selected_frame.
* tui/tui.c, tui/tuiDisassem.c, tui/tuiRegs.c: Ditto.
* tui/tuiSource.c, tui/tuiSourceWin.c, tui/tuiWin.c: Ditto.
2002-11-29 20:15:16 +01:00
|
|
|
/* On demand, create the selected frame and then return it. If the
|
|
|
|
selected frame can not be created, this function throws an error. */
|
|
|
|
/* FIXME: cagney/2002-11-28: At present, when there is no selected
|
|
|
|
frame, this function always returns the current (inner most) frame.
|
|
|
|
It should instead, when a thread has previously had its frame
|
|
|
|
selected (but not resumed) and the frame cache invalidated, find
|
|
|
|
and then return that thread's previously selected frame. */
|
|
|
|
extern struct frame_info *get_selected_frame (void);
|
|
|
|
|
2002-11-28 18:11:41 +01:00
|
|
|
/* Select a specific frame. NULL, apparently implies re-select the
|
|
|
|
inner most frame. */
|
|
|
|
extern void select_frame (struct frame_info *);
|
|
|
|
|
2002-11-15 16:50:21 +01:00
|
|
|
/* Given a FRAME, return the next (more inner, younger) or previous
|
|
|
|
(more outer, older) frame. */
|
|
|
|
extern struct frame_info *get_prev_frame (struct frame_info *);
|
|
|
|
extern struct frame_info *get_next_frame (struct frame_info *);
|
|
|
|
|
2003-06-16 22:05:56 +02:00
|
|
|
/* Given a FRAME, return the true next (more inner, younger) frame.
|
|
|
|
This one exposes the sentinel frame and, hence, never returns NULL.
|
|
|
|
It is here strictly to help old targets in their migration path to
|
|
|
|
the new frame code - the new code requires the NEXT, and not THIS
|
|
|
|
frame. */
|
|
|
|
extern struct frame_info *deprecated_get_next_frame_hack (struct frame_info *);
|
|
|
|
|
2002-11-15 16:50:21 +01:00
|
|
|
/* Given a frame's ID, relocate the frame. Returns NULL if the frame
|
|
|
|
is not found. */
|
|
|
|
extern struct frame_info *frame_find_by_id (struct frame_id id);
|
|
|
|
|
|
|
|
/* Base attributes of a frame: */
|
|
|
|
|
|
|
|
/* The frame's `resume' address. Where the program will resume in
|
2003-04-13 17:54:58 +02:00
|
|
|
this frame.
|
|
|
|
|
|
|
|
This replaced: frame->pc; */
|
2002-11-15 16:50:21 +01:00
|
|
|
extern CORE_ADDR get_frame_pc (struct frame_info *);
|
|
|
|
|
2003-07-11 16:52:17 +02:00
|
|
|
/* An address (not necessarily alligned to an instruction boundary)
|
|
|
|
that falls within THIS frame's code block.
|
|
|
|
|
|
|
|
When a function call is the last statement in a block, the return
|
|
|
|
address for the call may land at the start of the next block.
|
|
|
|
Similarly, if a no-return function call is the last statement in
|
|
|
|
the function, the return address may end up pointing beyond the
|
|
|
|
function, and possibly at the start of the next function.
|
|
|
|
|
|
|
|
These methods make an allowance for this. For call frames, this
|
|
|
|
function returns the frame's PC-1 which "should" be an address in
|
|
|
|
the frame's block. */
|
|
|
|
|
|
|
|
extern CORE_ADDR get_frame_address_in_block (struct frame_info *this_frame);
|
|
|
|
extern CORE_ADDR frame_unwind_address_in_block (struct frame_info *next_frame);
|
|
|
|
|
2003-06-09 03:02:07 +02:00
|
|
|
/* The frame's inner-most bound. AKA the stack-pointer. Confusingly
|
|
|
|
known as top-of-stack. */
|
|
|
|
|
|
|
|
extern CORE_ADDR get_frame_sp (struct frame_info *);
|
|
|
|
extern CORE_ADDR frame_sp_unwind (struct frame_info *);
|
|
|
|
|
|
|
|
|
2003-04-05 20:54:38 +02:00
|
|
|
/* Following on from the `resume' address. Return the entry point
|
|
|
|
address of the function containing that resume address, or zero if
|
|
|
|
that function isn't known. */
|
|
|
|
extern CORE_ADDR frame_func_unwind (struct frame_info *fi);
|
|
|
|
extern CORE_ADDR get_frame_func (struct frame_info *fi);
|
|
|
|
|
2002-11-29 02:52:02 +01:00
|
|
|
/* Closely related to the resume address, various symbol table
|
|
|
|
attributes that are determined by the PC. Note that for a normal
|
|
|
|
frame, the PC refers to the resume address after the return, and
|
|
|
|
not the call instruction. In such a case, the address is adjusted
|
|
|
|
so that it (approximatly) identifies the call site (and not return
|
|
|
|
site).
|
|
|
|
|
|
|
|
NOTE: cagney/2002-11-28: The frame cache could be used to cache the
|
|
|
|
computed value. Working on the assumption that the bottle-neck is
|
|
|
|
in the single step code, and that code causes the frame cache to be
|
|
|
|
constantly flushed, caching things in a frame is probably of little
|
|
|
|
benefit. As they say `show us the numbers'.
|
|
|
|
|
|
|
|
NOTE: cagney/2002-11-28: Plenty more where this one came from:
|
|
|
|
find_frame_block(), find_frame_partial_function(),
|
|
|
|
find_frame_symtab(), find_frame_function(). Each will need to be
|
|
|
|
carefully considered to determine if the real intent was for it to
|
|
|
|
apply to the PC or the adjusted PC. */
|
|
|
|
extern void find_frame_sal (struct frame_info *frame,
|
|
|
|
struct symtab_and_line *sal);
|
|
|
|
|
2003-04-01 21:11:01 +02:00
|
|
|
/* Return the frame base (what ever that is) (DEPRECATED).
|
|
|
|
|
|
|
|
Old code was trying to use this single method for two conflicting
|
|
|
|
purposes. Such code needs to be updated to use either of:
|
|
|
|
|
|
|
|
get_frame_id: A low level frame unique identifier, that consists of
|
|
|
|
both a stack and a function address, that can be used to uniquely
|
|
|
|
identify a frame. This value is determined by the frame's
|
|
|
|
low-level unwinder, the stack part [typically] being the
|
|
|
|
top-of-stack of the previous frame, and the function part being the
|
|
|
|
function's start address. Since the correct identification of a
|
|
|
|
frameless function requires both the a stack and function address,
|
|
|
|
the old get_frame_base method was not sufficient.
|
|
|
|
|
|
|
|
get_frame_base_address: get_frame_locals_address:
|
|
|
|
get_frame_args_address: A set of high-level debug-info dependant
|
|
|
|
addresses that fall within the frame. These addresses almost
|
|
|
|
certainly will not match the stack address part of a frame ID (as
|
2003-04-13 17:54:58 +02:00
|
|
|
returned by get_frame_base).
|
|
|
|
|
|
|
|
This replaced: frame->frame; */
|
2002-11-19 Andrew Cagney <ac131313@redhat.com>
* frame.h (FRAME_FP): Delete macro.
(get_frame_base): New function declaration.
* frame.c (get_frame_base): New function.
(get_frame_id): Use ->frame.
(frame_find_by_id): Rewrite to use get_frame_id.
* blockframe.c: Use get_frame_base instead of FRAME_FP.
* cris-tdep.c, d10v-tdep.c, findvar.c, h8500-tdep.c: Ditto.
* hppa-tdep.c, i386-tdep.c, infcmd.c, infrun.c: Ditto.
* m68hc11-tdep.c, m68k-tdep.c, mcore-tdep.c, mips-tdep.c: Ditto.
* mn10200-tdep.c, mn10300-tdep.c, rs6000-tdep.c: Ditto.
* sh-tdep.c, sparc-tdep.c, stack.c, tracepoint.c: Ditto.
* v850-tdep.c, valops.c, z8k-tdep.c: Ditto.
2002-11-24 20:48:13 +01:00
|
|
|
|
|
|
|
extern CORE_ADDR get_frame_base (struct frame_info *);
|
|
|
|
|
2002-11-15 16:50:21 +01:00
|
|
|
/* Return the per-frame unique identifer. Can be used to relocate a
|
2002-12-04 01:05:54 +01:00
|
|
|
frame after a frame cache flush (and other similar operations). If
|
|
|
|
FI is NULL, return the null_frame_id. */
|
|
|
|
extern struct frame_id get_frame_id (struct frame_info *fi);
|
2002-11-15 16:50:21 +01:00
|
|
|
|
2003-04-01 21:11:01 +02:00
|
|
|
/* Assuming that a frame is `normal', return its base-address, or 0 if
|
|
|
|
the information isn't available. NOTE: This address is really only
|
|
|
|
meaningful to the frame's high-level debug info. */
|
|
|
|
extern CORE_ADDR get_frame_base_address (struct frame_info *);
|
|
|
|
|
2003-04-01 21:26:52 +02:00
|
|
|
/* Assuming that a frame is `normal', return the base-address of the
|
|
|
|
local variables, or 0 if the information isn't available. NOTE:
|
2003-04-01 21:11:01 +02:00
|
|
|
This address is really only meaningful to the frame's high-level
|
|
|
|
debug info. Typically, the argument and locals share a single
|
|
|
|
base-address. */
|
|
|
|
extern CORE_ADDR get_frame_locals_address (struct frame_info *);
|
|
|
|
|
2003-04-01 21:26:52 +02:00
|
|
|
/* Assuming that a frame is `normal', return the base-address of the
|
|
|
|
parameter list, or 0 if that information isn't available. NOTE:
|
|
|
|
This address is really only meaningful to the frame's high-level
|
|
|
|
debug info. Typically, the argument and locals share a single
|
2003-04-01 21:11:01 +02:00
|
|
|
base-address. */
|
|
|
|
extern CORE_ADDR get_frame_args_address (struct frame_info *);
|
|
|
|
|
2002-11-15 16:50:21 +01:00
|
|
|
/* The frame's level: 0 for innermost, 1 for its caller, ...; or -1
|
|
|
|
for an invalid frame). */
|
|
|
|
extern int frame_relative_level (struct frame_info *fi);
|
|
|
|
|
2002-11-18 23:19:33 +01:00
|
|
|
/* Return the frame's type. Some are real, some are signal
|
|
|
|
trampolines, and some are completly artificial (dummy). */
|
|
|
|
|
|
|
|
enum frame_type
|
|
|
|
{
|
2003-04-05 05:56:00 +02:00
|
|
|
/* The frame's type hasn't yet been defined. This is a catch-all
|
|
|
|
for legacy code that uses really strange technicques, such as
|
|
|
|
deprecated_set_frame_type, to set the frame's type. New code
|
|
|
|
should not use this value. */
|
|
|
|
UNKNOWN_FRAME,
|
2002-11-18 23:19:33 +01:00
|
|
|
/* A true stack frame, created by the target program during normal
|
|
|
|
execution. */
|
|
|
|
NORMAL_FRAME,
|
|
|
|
/* A fake frame, created by GDB when performing an inferior function
|
|
|
|
call. */
|
|
|
|
DUMMY_FRAME,
|
|
|
|
/* In a signal handler, various OSs handle this in various ways.
|
|
|
|
The main thing is that the frame may be far from normal. */
|
|
|
|
SIGTRAMP_FRAME
|
|
|
|
};
|
|
|
|
extern enum frame_type get_frame_type (struct frame_info *);
|
|
|
|
|
|
|
|
/* FIXME: cagney/2002-11-10: Some targets want to directly mark a
|
|
|
|
frame as being of a specific type. This shouldn't be necessary.
|
2002-12-01 Andrew Cagney <ac131313@redhat.com>
* gdbarch.sh (DEPRECATED_PC_IN_CALL_DUMMY): Rename
PC_IN_CALL_DUMMY. Change to predicate. Always allow call.
* gdbarch.h, gdbarch.c: Re-generate.
* config/sparc/tm-sparc.h, config/sparc/tm-sp64.h: Update.
* config/mn10200/tm-mn10200.h, config/h8500/tm-h8500.h: Update.
* config/pa/tm-hppa.h, frame.h: Update.
* x86-64-tdep.c, vax-tdep.c, sparc-tdep.c: Update.
* s390-tdep.c, ns32k-tdep.c, mn10300-tdep.c: Update.
* m68k-tdep.c, i386-tdep.c, frv-tdep.c: Update.
* cris-tdep.c, alpha-tdep.c: Update.
* frame.c (set_unwind_by_pc, create_new_frame): Use either
DEPRECATED_PC_IN_CALL_DUMMY or pc_in_dummy_frame.
(get_prev_frame): Ditto.
Index: doc/ChangeLog
2002-12-01 Andrew Cagney <ac131313@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Delete
PC_IN_CALL_DUMMY.
2002-12-01 20:07:16 +01:00
|
|
|
PC_IN_SIGTRAMP() indicates a SIGTRAMP_FRAME and
|
|
|
|
DEPRECATED_PC_IN_CALL_DUMMY() indicates a DUMMY_FRAME. I suspect
|
|
|
|
the real problem here is that get_prev_frame() only sets
|
2003-03-02 01:11:43 +01:00
|
|
|
initialized after DEPRECATED_INIT_EXTRA_FRAME_INFO as been called.
|
2002-12-01 Andrew Cagney <ac131313@redhat.com>
* gdbarch.sh (DEPRECATED_PC_IN_CALL_DUMMY): Rename
PC_IN_CALL_DUMMY. Change to predicate. Always allow call.
* gdbarch.h, gdbarch.c: Re-generate.
* config/sparc/tm-sparc.h, config/sparc/tm-sp64.h: Update.
* config/mn10200/tm-mn10200.h, config/h8500/tm-h8500.h: Update.
* config/pa/tm-hppa.h, frame.h: Update.
* x86-64-tdep.c, vax-tdep.c, sparc-tdep.c: Update.
* s390-tdep.c, ns32k-tdep.c, mn10300-tdep.c: Update.
* m68k-tdep.c, i386-tdep.c, frv-tdep.c: Update.
* cris-tdep.c, alpha-tdep.c: Update.
* frame.c (set_unwind_by_pc, create_new_frame): Use either
DEPRECATED_PC_IN_CALL_DUMMY or pc_in_dummy_frame.
(get_prev_frame): Ditto.
Index: doc/ChangeLog
2002-12-01 Andrew Cagney <ac131313@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Delete
PC_IN_CALL_DUMMY.
2002-12-01 20:07:16 +01:00
|
|
|
Consequently, some targets found that the frame's type was wrong
|
|
|
|
and tried to fix it. The correct fix is to modify get_prev_frame()
|
|
|
|
so that it initializes the frame's type before calling any other
|
|
|
|
functions. */
|
2002-11-18 23:19:33 +01:00
|
|
|
extern void deprecated_set_frame_type (struct frame_info *,
|
|
|
|
enum frame_type type);
|
|
|
|
|
2002-11-15 16:50:21 +01:00
|
|
|
/* Unwind the stack frame so that the value of REGNUM, in the previous
|
|
|
|
(up, older) frame is returned. If VALUEP is NULL, don't
|
|
|
|
fetch/compute the value. Instead just return the location of the
|
|
|
|
value. */
|
|
|
|
extern void frame_register_unwind (struct frame_info *frame, int regnum,
|
|
|
|
int *optimizedp, enum lval_type *lvalp,
|
|
|
|
CORE_ADDR *addrp, int *realnump,
|
|
|
|
void *valuep);
|
|
|
|
|
2003-06-21 18:26:02 +02:00
|
|
|
/* Fetch a register from this, or unwind a register from the next
|
|
|
|
frame. Note that the get_frame methods are wrappers to
|
|
|
|
frame->next->unwind. They all [potentially] throw an error if the
|
|
|
|
fetch fails. */
|
2002-11-15 16:50:21 +01:00
|
|
|
|
2003-02-02 21:31:43 +01:00
|
|
|
extern void frame_unwind_register (struct frame_info *frame,
|
|
|
|
int regnum, void *buf);
|
2003-06-21 18:26:02 +02:00
|
|
|
extern void get_frame_register (struct frame_info *frame,
|
|
|
|
int regnum, void *buf);
|
|
|
|
|
|
|
|
extern LONGEST frame_unwind_register_signed (struct frame_info *frame,
|
|
|
|
int regnum);
|
|
|
|
extern LONGEST get_frame_register_signed (struct frame_info *frame,
|
|
|
|
int regnum);
|
|
|
|
extern ULONGEST frame_unwind_register_unsigned (struct frame_info *frame,
|
|
|
|
int regnum);
|
|
|
|
extern ULONGEST get_frame_register_unsigned (struct frame_info *frame,
|
|
|
|
int regnum);
|
|
|
|
|
2003-02-02 21:31:43 +01:00
|
|
|
|
2003-06-21 18:26:02 +02:00
|
|
|
/* Use frame_unwind_register_signed. */
|
2002-11-15 16:50:21 +01:00
|
|
|
extern void frame_unwind_signed_register (struct frame_info *frame,
|
|
|
|
int regnum, LONGEST *val);
|
|
|
|
|
2003-06-21 18:26:02 +02:00
|
|
|
/* Use frame_unwind_register_signed. */
|
2002-11-15 16:50:21 +01:00
|
|
|
extern void frame_unwind_unsigned_register (struct frame_info *frame,
|
|
|
|
int regnum, ULONGEST *val);
|
|
|
|
|
|
|
|
/* Get the value of the register that belongs to this FRAME. This
|
|
|
|
function is a wrapper to the call sequence ``frame_unwind_register
|
|
|
|
(get_next_frame (FRAME))''. As per frame_register_unwind(), if
|
|
|
|
VALUEP is NULL, the registers value is not fetched/computed. */
|
|
|
|
|
|
|
|
extern void frame_register (struct frame_info *frame, int regnum,
|
|
|
|
int *optimizedp, enum lval_type *lvalp,
|
|
|
|
CORE_ADDR *addrp, int *realnump,
|
|
|
|
void *valuep);
|
|
|
|
|
2003-06-14 Andrew Cagney <cagney@redhat.com>
Mark Kettenis <kettenis@gnu.org>
* gdbarch.sh (CONVERT_REGISTER_P): Add "type" parameter.
(REGISTER_TO_VALUE, VALUE_TO_REGISTER): Replace raw buffer
parameter with "frame".
* gdbarch.h, gdbarch.c: Re-generate.
* frame.h (put_frame_register): Declare.
* frame.c (put_frame_register): New function.
* arch-utils.c (legacy_convert_register_p): Add "type" parameter.
(legacy_register_to_value): Rewrite, use "frame" to get the
register value.
(legacy_value_to_register): Rewrite, use "frame" to find the
register's location before storing.
* arch-utils.h (legacy_convert_register_p): Update.
(legacy_register_to_value, legacy_value_to_register): Update.
* findvar.c (value_from_register): Rewrite, eliminate use of
REGISTER_CONVERT_TO_TYPE, pass "type" to CONVERT_REGISTER_P, pass
"frame" to REGISTER_TO_VALUE.
* valops.c (value_assign): Move the CONVERT_REGISTER code to the
lval_reg_frame_relative + lval_register branch of the switch. Do
not use REGISTER_CONVERT_FROM_TYPE. Use put_frame_register.
* i386-tdep.c (I386_EBX_REGNUM, I386_ECX_REGNUM, I386_ESI_REGNUM,
I386_EDI_REGNUM): New defines.
(i386_next_regnum, i386_convert_register_p,
i386_register_to_value, i386_value_to_register): New functions.
(i386_register_convertible, i386_register_convert_to_virtual,
i386_convert_to_raw): Remove functions.
(i386_gdbarch_init): Set convert_register_p, register_to_value and
value_to_register instead of register_convertible,
register_convert_to_virtual and register_convert_to_raw.
* mips-tdep.c (mips_convert_register_p): New function.
(mips_value_to_register): Replace mips_register_convert_from_type.
(mips_register_to_value): Replace mips_register_convert_to_type.
(mips_gdbarch_init): Set conver_register_p, value_to_register and
register_to_value.
* alpha-tdep.c (alpha_convert_register_p): Update.
(alpha_value_to_register): Update, store the register.
(alpha_register_to_value): Update, fetch the register.
2003-06-15 00:35:25 +02:00
|
|
|
/* The reverse. Store a register value relative to the specified
|
|
|
|
frame. Note: this call makes the frame's state undefined. The
|
|
|
|
register and frame caches must be flushed. */
|
|
|
|
extern void put_frame_register (struct frame_info *frame, int regnum,
|
|
|
|
const void *buf);
|
|
|
|
|
2002-11-15 16:50:21 +01:00
|
|
|
/* Map between a frame register number and its name. A frame register
|
|
|
|
space is a superset of the cooked register space --- it also
|
2003-02-02 19:53:22 +01:00
|
|
|
includes builtin registers. If NAMELEN is negative, use the NAME's
|
|
|
|
length when doing the comparison. */
|
2002-11-15 16:50:21 +01:00
|
|
|
|
2003-07-07 16:36:58 +02:00
|
|
|
extern int frame_map_name_to_regnum (struct frame_info *frame,
|
|
|
|
const char *name, int namelen);
|
|
|
|
extern const char *frame_map_regnum_to_name (struct frame_info *frame,
|
|
|
|
int regnum);
|
2002-11-15 16:50:21 +01:00
|
|
|
|
2002-11-15 23:16:25 +01:00
|
|
|
/* Unwind the PC. Strictly speaking return the resume address of the
|
|
|
|
calling frame. For GDB, `pc' is the resume address and not a
|
|
|
|
specific register. */
|
|
|
|
|
|
|
|
extern CORE_ADDR frame_pc_unwind (struct frame_info *frame);
|
|
|
|
|
2003-01-19 18:39:16 +01:00
|
|
|
/* Discard the specified frame. Restoring the registers to the state
|
|
|
|
of the caller. */
|
|
|
|
extern void frame_pop (struct frame_info *frame);
|
|
|
|
|
2003-06-03 20:53:37 +02:00
|
|
|
/* Return memory from the specified frame. A frame knows its thread /
|
|
|
|
LWP and hence can find its way down to a target. The assumption
|
|
|
|
here is that the current and previous frame share a common address
|
|
|
|
space.
|
|
|
|
|
|
|
|
If the memory read fails, these methods throw an error.
|
|
|
|
|
|
|
|
NOTE: cagney/2003-06-03: Should there be unwind versions of these
|
|
|
|
methods? That isn't clear. Can code, for instance, assume that
|
|
|
|
this and the previous frame's memory or architecture are identical?
|
|
|
|
If architecture / memory changes are always separated by special
|
|
|
|
adaptor frames this should be ok. */
|
|
|
|
|
|
|
|
extern void get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
|
|
|
|
void *buf, int len);
|
|
|
|
extern LONGEST get_frame_memory_signed (struct frame_info *this_frame,
|
|
|
|
CORE_ADDR memaddr, int len);
|
|
|
|
extern ULONGEST get_frame_memory_unsigned (struct frame_info *this_frame,
|
|
|
|
CORE_ADDR memaddr, int len);
|
|
|
|
|
|
|
|
/* Return this frame's architecture. */
|
|
|
|
|
|
|
|
extern struct gdbarch *get_frame_arch (struct frame_info *this_frame);
|
|
|
|
|
|
|
|
|
2000-01-18 01:55:13 +01:00
|
|
|
/* Values for the source flag to be used in print_frame_info_base(). */
|
|
|
|
enum print_what
|
|
|
|
{
|
|
|
|
/* Print only the source line, like in stepi. */
|
|
|
|
SRC_LINE = -1,
|
|
|
|
/* Print only the location, i.e. level, address (sometimes)
|
|
|
|
function, args, file, line, line num. */
|
|
|
|
LOCATION,
|
|
|
|
/* Print both of the above. */
|
|
|
|
SRC_AND_LOC,
|
|
|
|
/* Print location only, but always include the address. */
|
|
|
|
LOC_AND_ADDRESS
|
|
|
|
};
|
|
|
|
|
2001-03-21 17:42:39 +01:00
|
|
|
/* Allocate additional space for appendices to a struct frame_info.
|
|
|
|
NOTE: Much of GDB's code works on the assumption that the allocated
|
|
|
|
saved_regs[] array is the size specified below. If you try to make
|
|
|
|
that array smaller, GDB will happily walk off its end. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2001-03-21 17:42:39 +01:00
|
|
|
#ifdef SIZEOF_FRAME_SAVED_REGS
|
|
|
|
#error "SIZEOF_FRAME_SAVED_REGS can not be re-defined"
|
1999-04-16 03:35:26 +02:00
|
|
|
#endif
|
2001-03-21 17:42:39 +01:00
|
|
|
#define SIZEOF_FRAME_SAVED_REGS \
|
|
|
|
(sizeof (CORE_ADDR) * (NUM_REGS+NUM_PSEUDO_REGS))
|
|
|
|
|
2003-01-09 19:53:21 +01:00
|
|
|
/* Allocate zero initialized memory from the frame cache obstack.
|
|
|
|
Appendices to the frame info (such as the unwind cache) should
|
|
|
|
allocate memory using this method. */
|
|
|
|
|
|
|
|
extern void *frame_obstack_zalloc (unsigned long size);
|
2003-01-21 20:32:42 +01:00
|
|
|
#define FRAME_OBSTACK_ZALLOC(TYPE) ((TYPE *) frame_obstack_zalloc (sizeof (TYPE)))
|
2003-04-25 23:20:58 +02:00
|
|
|
#define FRAME_OBSTACK_CALLOC(NUMBER,TYPE) ((TYPE *) frame_obstack_zalloc ((NUMBER) * sizeof (TYPE)))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2003-04-06 20:36:23 +02:00
|
|
|
/* If legacy_frame_chain_valid() returns zero it means that the given
|
|
|
|
frame is the outermost one and has no caller.
|
|
|
|
|
|
|
|
This method has been superseeded by the per-architecture
|
|
|
|
frame_unwind_pc() (returns 0 to indicate an invalid return address)
|
|
|
|
and per-frame this_id() (returns a NULL frame ID to indicate an
|
|
|
|
invalid frame). */
|
|
|
|
extern int legacy_frame_chain_valid (CORE_ADDR, struct frame_info *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern void generic_save_dummy_frame_tos (CORE_ADDR sp);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gdb/ChangeLog:
* stack.c (get_selected_block): Add new argument `addr_in_block',
used to return the exact code address we used to select the block,
not just the block.
* blockframe.c (get_frame_block, get_current_block): Same.
* frame.h (get_frame_block, get_current_block,
get_selected_block): Update declarations.
* linespec.c, stack.c, blockframe.c, breakpoint.c, findvar.c,
linespec.c, varobj.c, printcmd.c, symtab.c: Callers changed.
gdb/mi/ChangeLog:
* mi-cmd-stack.c (list_args_or_locals): Pass new arg to
get_frame_block. (See entry in gdb/ChangeLog.)
2002-04-06 00:04:43 +02:00
|
|
|
extern struct block *get_frame_block (struct frame_info *,
|
|
|
|
CORE_ADDR *addr_in_block);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2002-11-29 16:39:51 +01:00
|
|
|
/* Return the `struct block' that belongs to the selected thread's
|
|
|
|
selected frame. If the inferior has no state, return NULL.
|
|
|
|
|
|
|
|
NOTE: cagney/2002-11-29:
|
|
|
|
|
|
|
|
No state? Does the inferior have any execution state (a core file
|
|
|
|
does, an executable does not). At present the code tests
|
|
|
|
`target_has_stack' but I'm left wondering if it should test
|
|
|
|
`target_has_registers' or, even, a merged target_has_state.
|
|
|
|
|
|
|
|
Should it look at the most recently specified SAL? If the target
|
|
|
|
has no state, should this function try to extract a block from the
|
|
|
|
most recently selected SAL? That way `list foo' would give it some
|
|
|
|
sort of reference point. Then again, perhaphs that would confuse
|
|
|
|
things.
|
|
|
|
|
|
|
|
Calls to this function can be broken down into two categories: Code
|
|
|
|
that uses the selected block as an additional, but optional, data
|
|
|
|
point; Code that uses the selected block as a prop, when it should
|
|
|
|
have the relevant frame/block/pc explicitly passed in.
|
|
|
|
|
|
|
|
The latter can be eliminated by correctly parameterizing the code,
|
|
|
|
the former though is more interesting. Per the "address" command,
|
|
|
|
it occures in the CLI code and makes it possible for commands to
|
|
|
|
work, even when the inferior has no state. */
|
|
|
|
|
gdb/ChangeLog:
* stack.c (get_selected_block): Add new argument `addr_in_block',
used to return the exact code address we used to select the block,
not just the block.
* blockframe.c (get_frame_block, get_current_block): Same.
* frame.h (get_frame_block, get_current_block,
get_selected_block): Update declarations.
* linespec.c, stack.c, blockframe.c, breakpoint.c, findvar.c,
linespec.c, varobj.c, printcmd.c, symtab.c: Callers changed.
gdb/mi/ChangeLog:
* mi-cmd-stack.c (list_args_or_locals): Pass new arg to
get_frame_block. (See entry in gdb/ChangeLog.)
2002-04-06 00:04:43 +02:00
|
|
|
extern struct block *get_selected_block (CORE_ADDR *addr_in_block);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern struct symbol *get_frame_function (struct frame_info *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern CORE_ADDR get_pc_function_start (CORE_ADDR);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern int frameless_look_for_prologue (struct frame_info *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern struct frame_info *find_relative_frame (struct frame_info *, int *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern void show_and_print_stack_frame (struct frame_info *fi, int level,
|
|
|
|
int source);
|
1999-04-26 20:34:20 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern void print_stack_frame (struct frame_info *, int, int);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern void show_stack_frame (struct frame_info *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern void print_frame_info (struct frame_info *, int, int, int);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern void show_frame_info (struct frame_info *, int, int, int);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern struct frame_info *block_innermost_frame (struct block *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2002-09-17 22:42:01 +02:00
|
|
|
/* NOTE: cagney/2002-09-13: There is no need for this function.
|
|
|
|
Instead either of frame_unwind_signed_register() or
|
|
|
|
frame_unwind_unsigned_register() can be used. */
|
|
|
|
extern CORE_ADDR deprecated_read_register_dummy (CORE_ADDR pc,
|
|
|
|
CORE_ADDR fp, int);
|
2000-05-28 03:12:42 +02:00
|
|
|
extern void generic_push_dummy_frame (void);
|
|
|
|
extern void generic_pop_current_frame (void (*)(struct frame_info *));
|
|
|
|
extern void generic_pop_dummy_frame (void);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
extern int generic_pc_in_call_dummy (CORE_ADDR pc,
|
|
|
|
CORE_ADDR sp, CORE_ADDR fp);
|
2002-06-26 17:28:46 +02:00
|
|
|
|
|
|
|
/* NOTE: cagney/2002-06-26: Targets should no longer use this
|
|
|
|
function. Instead, the contents of a dummy frames registers can be
|
|
|
|
obtained by applying: frame_register_unwind to the dummy frame; or
|
2003-03-14 18:07:01 +01:00
|
|
|
frame_register_unwind() to the next outer frame. */
|
2002-06-26 17:28:46 +02:00
|
|
|
|
|
|
|
extern char *deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2003-06-10 00:20:43 +02:00
|
|
|
|
|
|
|
/* The DEPRECATED_GET_SAVED_REGISTER architecture interface is
|
|
|
|
entirely redundant. New architectures should implement per-frame
|
|
|
|
unwinders (ref "frame-unwind.h"). */
|
2002-11-01 22:21:49 +01:00
|
|
|
extern void deprecated_generic_get_saved_register (char *, int *, CORE_ADDR *,
|
|
|
|
struct frame_info *, int,
|
|
|
|
enum lval_type *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
2002-04-26 05:37:42 +02:00
|
|
|
extern void generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi);
|
|
|
|
|
2003-02-02 21:31:43 +01:00
|
|
|
/* FIXME: cagney/2003-02-02: Should be deprecated or replaced with a
|
2003-09-29 00:32:20 +02:00
|
|
|
function called get_frame_register_p(). This slightly weird (and
|
|
|
|
older) variant of get_frame_register() returns zero (indicating the
|
|
|
|
register is unavailable) if either: the register isn't cached; or
|
|
|
|
the register has been optimized out. Problem is, neither check is
|
|
|
|
exactly correct. A register can't be optimized out (it may not
|
2003-02-02 21:31:43 +01:00
|
|
|
have been saved as part of a function call); The fact that a
|
|
|
|
register isn't in the register cache doesn't mean that the register
|
|
|
|
isn't available (it could have been fetched from memory). */
|
|
|
|
|
2002-04-12 20:18:59 +02:00
|
|
|
extern int frame_register_read (struct frame_info *frame, int regnum,
|
|
|
|
void *buf);
|
|
|
|
|
2002-10-02 Elena Zannoni <ezannoni@redhat.com>
* inferior.h (registers_info, stepi_command, nexti_command,
continue_command, interrupt_target_command): Export from infcmd.c.
* frame.h (args_info, selected_frame_level_changed_hook,
return_command): Export from stack.c.
* v850ice.c (stepi_command, nexti_command, continue_command): use
prototypes from inferior.h.
* tracepoint.c (registers_info, args_info, locals_info): Use
prototypes from frame.h and inferior.h.
* Makefile.in (mi-main.o): Add dependency on frame.h.
2002-10-02 Elena Zannoni <ezannoni@redhat.com>
* mi-main.c (mi_cmd_exec_return): Don't use
return_command_wrapper, use return_command instead.
(mi_cmd_exec_interrupt): Don't use
interrupt_target_command_wrapper, use interrupt_target_command
instead.
(return_command_wrapper, interrupt_target_command_wrapper):
Delete.
Include frame.h.
2002-10-02 Elena Zannoni <ezannoni@redhat.com>
* tui-hooks.c (selected_frame_level_changed_hook): Use the one
exported from frame.h.
2002-10-02 23:33:59 +02:00
|
|
|
/* From stack.c. */
|
|
|
|
extern void args_info (char *, int);
|
|
|
|
|
|
|
|
extern void locals_info (char *, int);
|
|
|
|
|
|
|
|
extern void (*selected_frame_level_changed_hook) (int);
|
|
|
|
|
|
|
|
extern void return_command (char *, int);
|
|
|
|
|
2002-11-28 18:11:41 +01:00
|
|
|
|
|
|
|
/* NOTE: cagney/2002-11-27:
|
|
|
|
|
|
|
|
You might think that the below global can simply be replaced by a
|
|
|
|
call to either get_selected_frame() or select_frame().
|
|
|
|
|
Index: mi/ChangeLog
2003-10-24 Andrew Cagney <cagney@redhat.com>
* tui-out.c: Fix "fortunatly"[sic].
Index: doc/ChangeLog
2003-10-24 Andrew Cagney <cagney@redhat.com>
* annotate.texinfo: Fix "fortunatly"[sic].
2003-10-24 Andrew Cagney <cagney@redhat.com>
* osabi.c (gdbarch_init_osabi): Fix typos, and "fortunatly"[sic].
* PROBLEMS, arch-utils.c, cli-out.c, command.h: Ditto.
* complaints.c, cris-tdep.c, disasm.c, dwarf2-frame.c: Ditto.
* frame.c, frame.h, infcall.c, infcmd.c, infrun.c: Ditto.
* kod.c, mips-tdep.c, regcache.c, regcache.h, remote.c: Ditto.
2003-10-24 19:37:04 +02:00
|
|
|
Unfortunately, it isn't that easy.
|
2002-11-28 18:11:41 +01:00
|
|
|
|
|
|
|
The relevant code needs to be audited to determine if it is
|
|
|
|
possible (or pratical) to instead pass the applicable frame in as a
|
|
|
|
parameter. For instance, DEPRECATED_DO_REGISTERS_INFO() relied on
|
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* stack.c (selected_frame, select_frame): Move from here ...
* frame.c (selected_frame, select_frame): ... to here. Include
"language.h".
* Makefile.in (frame.o): Update dependencies.
* frame.c (get_selected_frame): New function.
* frame.h (get_selected_frame): Declare.
(deprecated_selected_frame): Rename selected_frame.
* ada-lang.c, ada-tasks.c, breakpoint.c, corelow.c: Update.
* eval.c, f-valprint.c, findvar.c, frame.c, frame.h: Update.
* h8300-tdep.c, h8500-tdep.c, hppa-tdep.c, infcmd.c: Update.
* inflow.c, infrun.c, macroscope.c, mips-tdep.c: Update.
* mn10300-tdep.c, ocd.c, regcache.h, remote-e7000.c: Update.
* remote-mips.c, remote-rdp.c, sh-tdep.c, sparc-tdep.c: Update.
* stack.c, thread.c, tracepoint.c, valops.c, varobj.c: Update.
* z8k-tdep.c, cli/cli-cmds.c: Update.
Index: mi/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* mi/mi-cmd-stack.c, mi/mi-main.c: Update to use
deprecated_selected_frame.
Index: tui/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* tui/tui-hooks.c: Update to use deprecated_selected_frame.
* tui/tui.c, tui/tuiDisassem.c, tui/tuiRegs.c: Ditto.
* tui/tuiSource.c, tui/tuiSourceWin.c, tui/tuiWin.c: Ditto.
2002-11-29 20:15:16 +01:00
|
|
|
the deprecated_selected_frame global, while its replacement,
|
2002-11-28 18:11:41 +01:00
|
|
|
PRINT_REGISTERS_INFO(), is parameterized with the selected frame.
|
|
|
|
The only real exceptions occure at the edge (in the CLI code) where
|
|
|
|
user commands need to pick up the selected frame before proceeding.
|
|
|
|
|
|
|
|
This is important. GDB is trying to stamp out the hack:
|
|
|
|
|
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* stack.c (selected_frame, select_frame): Move from here ...
* frame.c (selected_frame, select_frame): ... to here. Include
"language.h".
* Makefile.in (frame.o): Update dependencies.
* frame.c (get_selected_frame): New function.
* frame.h (get_selected_frame): Declare.
(deprecated_selected_frame): Rename selected_frame.
* ada-lang.c, ada-tasks.c, breakpoint.c, corelow.c: Update.
* eval.c, f-valprint.c, findvar.c, frame.c, frame.h: Update.
* h8300-tdep.c, h8500-tdep.c, hppa-tdep.c, infcmd.c: Update.
* inflow.c, infrun.c, macroscope.c, mips-tdep.c: Update.
* mn10300-tdep.c, ocd.c, regcache.h, remote-e7000.c: Update.
* remote-mips.c, remote-rdp.c, sh-tdep.c, sparc-tdep.c: Update.
* stack.c, thread.c, tracepoint.c, valops.c, varobj.c: Update.
* z8k-tdep.c, cli/cli-cmds.c: Update.
Index: mi/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* mi/mi-cmd-stack.c, mi/mi-main.c: Update to use
deprecated_selected_frame.
Index: tui/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* tui/tui-hooks.c: Update to use deprecated_selected_frame.
* tui/tui.c, tui/tuiDisassem.c, tui/tuiRegs.c: Ditto.
* tui/tuiSource.c, tui/tuiSourceWin.c, tui/tuiWin.c: Ditto.
2002-11-29 20:15:16 +01:00
|
|
|
saved_frame = deprecated_selected_frame;
|
|
|
|
deprecated_selected_frame = ...;
|
2002-11-28 18:11:41 +01:00
|
|
|
hack_using_global_selected_frame ();
|
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* stack.c (selected_frame, select_frame): Move from here ...
* frame.c (selected_frame, select_frame): ... to here. Include
"language.h".
* Makefile.in (frame.o): Update dependencies.
* frame.c (get_selected_frame): New function.
* frame.h (get_selected_frame): Declare.
(deprecated_selected_frame): Rename selected_frame.
* ada-lang.c, ada-tasks.c, breakpoint.c, corelow.c: Update.
* eval.c, f-valprint.c, findvar.c, frame.c, frame.h: Update.
* h8300-tdep.c, h8500-tdep.c, hppa-tdep.c, infcmd.c: Update.
* inflow.c, infrun.c, macroscope.c, mips-tdep.c: Update.
* mn10300-tdep.c, ocd.c, regcache.h, remote-e7000.c: Update.
* remote-mips.c, remote-rdp.c, sh-tdep.c, sparc-tdep.c: Update.
* stack.c, thread.c, tracepoint.c, valops.c, varobj.c: Update.
* z8k-tdep.c, cli/cli-cmds.c: Update.
Index: mi/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* mi/mi-cmd-stack.c, mi/mi-main.c: Update to use
deprecated_selected_frame.
Index: tui/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* tui/tui-hooks.c: Update to use deprecated_selected_frame.
* tui/tui.c, tui/tuiDisassem.c, tui/tuiRegs.c: Ditto.
* tui/tuiSource.c, tui/tuiSourceWin.c, tui/tuiWin.c: Ditto.
2002-11-29 20:15:16 +01:00
|
|
|
deprecated_selected_frame = saved_frame;
|
2002-11-28 18:11:41 +01:00
|
|
|
|
|
|
|
Take care! */
|
|
|
|
|
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* stack.c (selected_frame, select_frame): Move from here ...
* frame.c (selected_frame, select_frame): ... to here. Include
"language.h".
* Makefile.in (frame.o): Update dependencies.
* frame.c (get_selected_frame): New function.
* frame.h (get_selected_frame): Declare.
(deprecated_selected_frame): Rename selected_frame.
* ada-lang.c, ada-tasks.c, breakpoint.c, corelow.c: Update.
* eval.c, f-valprint.c, findvar.c, frame.c, frame.h: Update.
* h8300-tdep.c, h8500-tdep.c, hppa-tdep.c, infcmd.c: Update.
* inflow.c, infrun.c, macroscope.c, mips-tdep.c: Update.
* mn10300-tdep.c, ocd.c, regcache.h, remote-e7000.c: Update.
* remote-mips.c, remote-rdp.c, sh-tdep.c, sparc-tdep.c: Update.
* stack.c, thread.c, tracepoint.c, valops.c, varobj.c: Update.
* z8k-tdep.c, cli/cli-cmds.c: Update.
Index: mi/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* mi/mi-cmd-stack.c, mi/mi-main.c: Update to use
deprecated_selected_frame.
Index: tui/ChangeLog
2002-11-29 Andrew Cagney <ac131313@redhat.com>
* tui/tui-hooks.c: Update to use deprecated_selected_frame.
* tui/tui.c, tui/tuiDisassem.c, tui/tuiRegs.c: Ditto.
* tui/tuiSource.c, tui/tuiSourceWin.c, tui/tuiWin.c: Ditto.
2002-11-29 20:15:16 +01:00
|
|
|
extern struct frame_info *deprecated_selected_frame;
|
2002-11-28 18:11:41 +01:00
|
|
|
|
2003-09-08 20:56:03 +02:00
|
|
|
/* NOTE: drow/2003-09-06:
|
|
|
|
|
|
|
|
This function is "a step sideways" for uses of deprecated_selected_frame.
|
|
|
|
They should be fixed as above, but meanwhile, we needed a solution for
|
|
|
|
cases where functions are called with a NULL frame meaning either "the
|
|
|
|
program is not running" or "use the selected frame". Lazy building of
|
|
|
|
deprecated_selected_frame confuses the situation, because now
|
|
|
|
deprecated_selected_frame can be NULL even when the inferior is running.
|
|
|
|
|
|
|
|
This function calls get_selected_frame if the inferior should have a
|
|
|
|
frame, or returns NULL otherwise. */
|
|
|
|
|
|
|
|
extern struct frame_info *deprecated_safe_get_selected_frame (void);
|
2002-11-28 18:11:41 +01:00
|
|
|
|
2002-12-13 17:26:02 +01:00
|
|
|
/* Create a frame using the specified BASE and PC. */
|
2002-11-28 18:11:41 +01:00
|
|
|
|
2002-12-13 17:26:02 +01:00
|
|
|
extern struct frame_info *create_new_frame (CORE_ADDR base, CORE_ADDR pc);
|
2002-11-28 18:11:41 +01:00
|
|
|
|
2002-12-12 01:56:44 +01:00
|
|
|
|
2002-12-13 17:11:32 +01:00
|
|
|
/* Create/access the frame's `extra info'. The extra info is used by
|
|
|
|
older code to store information such as the analyzed prologue. The
|
|
|
|
zalloc() should only be called by the INIT_EXTRA_INFO method. */
|
2002-12-12 01:56:44 +01:00
|
|
|
|
2002-12-13 17:11:32 +01:00
|
|
|
extern struct frame_extra_info *frame_extra_info_zalloc (struct frame_info *fi,
|
|
|
|
long size);
|
2002-12-12 01:56:44 +01:00
|
|
|
extern struct frame_extra_info *get_frame_extra_info (struct frame_info *fi);
|
|
|
|
|
2002-12-14 00:18:56 +01:00
|
|
|
/* Create/access the frame's `saved_regs'. The saved regs are used by
|
|
|
|
older code to store the address of each register (except for
|
|
|
|
SP_REGNUM where the value of the register in the previous frame is
|
|
|
|
stored). */
|
|
|
|
extern CORE_ADDR *frame_saved_regs_zalloc (struct frame_info *);
|
2003-09-25 Andrew Cagney <cagney@redhat.com>
* frame.h (deprecated_frame_saved_regs): Rename
get_frame_saved_regs.
* cris-tdep.c, frame.c, h8300-tdep.c, hppa-tdep.c: Update.
* mcore-tdep.c, mips-tdep.c, mn10300-tdep.c: Update.
* ns32k-tdep.c, ppc-linux-tdep.c, rs6000-tdep.c: Update.
* s390-tdep.c, sh64-tdep.c, stack.c: Update.
* v850-tdep.c, vax-tdep.c, xstormy16-tdep.c: Update.
2003-09-25 22:44:02 +02:00
|
|
|
extern CORE_ADDR *deprecated_get_frame_saved_regs (struct frame_info *);
|
2002-12-14 00:18:56 +01:00
|
|
|
|
2002-12-13 22:57:40 +01:00
|
|
|
/* FIXME: cagney/2002-12-06: Has the PC in the current frame changed?
|
|
|
|
"infrun.c", Thanks to DECR_PC_AFTER_BREAK, can change the PC after
|
2003-04-13 17:54:58 +02:00
|
|
|
the initial frame create. This puts things back in sync.
|
|
|
|
|
|
|
|
This replaced: frame->pc = ....; */
|
2002-12-18 19:03:42 +01:00
|
|
|
extern void deprecated_update_frame_pc_hack (struct frame_info *frame,
|
|
|
|
CORE_ADDR pc);
|
|
|
|
|
|
|
|
/* FIXME: cagney/2002-12-18: Has the frame's base changed? Or to be
|
2003-10-10 02:32:04 +02:00
|
|
|
more exact, was that initial guess at the frame's base as returned
|
|
|
|
by deprecated_read_fp() wrong? If it was, fix it. This shouldn't
|
2003-04-28 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_TARGET_READ_FP): Replace TARGET_READ_FP.
(DEPRECATED_FP_REGNUM): Replace FP_REGNUM.
* gdbarch.h, gdbarch.c: Re-generate.
* infcall.c (call_function_by_hand): Use DEPRECATED_FP_REGNUM,
DEPRECATED_TARGET_READ_FP, or "sp" to create the dummy frame ID.
* inferior.h (deprecated_read_fp): Rename read_fp.
(generic_target_read_fp): Delete declaration.
* regcache.c (generic_target_read_fp): Delete function.
(deprecated_read_fp): Replace read_fp, use
DEPRECATED_TARGET_READ_FP or DEPRECATED_FP_REGNUM.
* d10v-tdep.c (d10v_read_fp): Delete function.
(d10v_gdbarch_init): Do not set deprecated_read_fp.
* sparc-tdep.c (sparc_gdbarch_init): Do not set
deprecated_target_read_fp to generic_target_read_fp.
* sh-tdep.c (sh_gdbarch_init): Ditto.
* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
* frv-tdep.c (frv_gdbarch_init): Ditto.
* xstormy16-tdep.c (xstormy16_gdbarch_init): Set
deprecated_fp_regnum.
* x86-64-tdep.c (x86_64_init_abi): Ditto.
* vax-tdep.c (vax_gdbarch_init): Ditto.
* v850-tdep.c (v850_gdbarch_init): Ditto.
* sparc-tdep.c (sparc_gdbarch_init): Ditto.
* sh-tdep.c (sh_gdbarch_init): Ditto.
* s390-tdep.c (s390_gdbarch_init): Ditto.
* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
* mn10300-tdep.c (mn10300_gdbarch_init): Ditto.
* mcore-tdep.c (mcore_gdbarch_init): Ditto.
* m68k-tdep.c (m68k_gdbarch_init): Ditto.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
* ia64-tdep.c (ia64_gdbarch_init): Ditto.
* i386-tdep.c (i386_gdbarch_init): Ditto.
* hppa-tdep.c (hppa_gdbarch_init): Ditto.
* h8300-tdep.c (h8300_gdbarch_init): Ditto.
* frv-tdep.c (frv_gdbarch_init): Ditto.
* cris-tdep.c (cris_gdbarch_init): Ditto.
* avr-tdep.c (avr_gdbarch_init): Ditto.
* arm-tdep.c (arm_gdbarch_init): Ditto.
* alpha-tdep.c (alpha_gdbarch_init): Ditto.
* x86-64-tdep.c (x86_64_init_abi): Set deprecated_target_read_fp.
* v850-tdep.c (v850_gdbarch_init): Ditto.
* sparc-tdep.c (sparc_gdbarch_init): Ditto.
* sh-tdep.c (sh_gdbarch_init): Ditto.
* s390-tdep.c (s390_gdbarch_init): Ditto.
* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
* mn10300-tdep.c (mn10300_gdbarch_init): Ditto.
* mips-tdep.c (mips_gdbarch_init): Ditto.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
* ia64-tdep.c (ia64_gdbarch_init): Ditto.
* hppa-tdep.c (hppa_gdbarch_init): Ditto.
* frv-tdep.c (frv_gdbarch_init): Ditto.
* avr-tdep.c (avr_gdbarch_init): Ditto.
* arm-tdep.c (arm_gdbarch_init): Ditto.
* vax-tdep.c (vax_frame_init_saved_regs): Replace FP_REGNUM with
DEPRECATED_FP_REGNUM.
(vax_push_dummy_frame, vax_pop_frame): Ditto.
* std-regs.c (value_of_builtin_frame_fp_reg): Ditto.
* sparc-tdep.c (sparc_init_extra_frame_info): Ditto.
(sparc_push_dummy_frame, sparc64_read_fp): Ditto.
(sparc32_register_virtual_type): Ditto.
* sh-tdep.c (sh64_frame_chain): Ditto.
(sh64_get_saved_register, sh64_pop_frame): Ditto.
(sh_nofp_frame_init_saved_regs): Ditto.
(sh64_nofp_frame_init_saved_regs): Ditto.
(sh_fp_frame_init_saved_regs): Ditto.
* remote-mips.c (mips_wait, mips_fetch_registers): Ditto.
* remote-e7000.c (fetch_regs_from_dump): Ditto.
* procfs.c (procfs_fetch_registers): Ditto.
(procfs_store_registers): Ditto.
* ns32knbsd-nat.c (fetch_inferior_registers): Ditto.
(store_inferior_registers, fetch_core_registers): Ditto.
(fetch_kcore_registers, clear_regs): Ditto.
* ns32k-tdep.c (ns32k_frame_init_saved_regs): Ditto.
(ns32k_push_dummy_frame, ns32k_pop_frame): Ditto.
* nlm/i386.h (DEPRECATED_FP_REGNUM): Ditto.
* nlm/i386.c (do_status): Ditto.
* mipsv4-nat.c (supply_gregset): Ditto.
* mips-tdep.c: Ditto for comments.
* mips-nat.c (fetch_inferior_registers): Ditto.
(store_inferior_registers, fetch_core_registers): Ditto.
* m68k-tdep.c (m68k_push_dummy_frame): Ditto.
(m68k_pop_frame, m68k_frame_init_saved_regs): Ditto.
* i386-tdep.c (i386_frame_init_saved_regs): Ditto.
(i386_do_pop_frame, i386_register_type): Ditto.
* hppa-tdep.c (hppa_frame_chain): Ditto.
(hppa_push_dummy_frame, find_dummy_frame_regs): Ditto.
(hppa_pop_frame, hppa_read_fp): Ditto.
(skip_prologue_hard_way, hppa_frame_find_saved_regs): Ditto.
* cris-tdep.c (cris_examine, cris_pop_frame): Ditto.
* config/vax/nm-vax.h (REGISTER_U_ADDR): Ditto.
* config/sparc/tm-sparc.h (DEPRECATED_FP_REGNUM): Ditto.
* config/sparc/tm-sp64.h (DEPRECATED_FP_REGNUM): Ditto.
* config/s390/tm-s390.h (DEPRECATED_FP_REGNUM): Ditto.
* config/pa/tm-hppa64.h (DEPRECATED_FP_REGNUM): Ditto.
* config/ia64/tm-ia64.h (DEPRECATED_FP_REGNUM): Ditto.
* blockframe.c: Ditto for comments.
* arch-utils.h: Ditto for comments.
* arch-utils.c (legacy_virtual_frame_pointer): Ditto.
* alphanbsd-tdep.c (fetch_core_registers): Ditto.
* alphabsd-nat.c (fetch_inferior_registers): Ditto.
* alpha-tdep.h: Ditto for comments.
* alpha-tdep.c (alpha_cannot_fetch_register): Ditto.
(alpha_cannot_store_register): Ditto.
(alpha_push_dummy_frame): Ditto.
* alpha-nat.c (supply_gregset): Ditto.
* config/sparc/tm-sp64.h (DEPRECATED_TARGET_READ_FP): Update.
* config/pa/tm-hppa64.h (DEPRECATED_TARGET_READ_FP): Update.
* config/sparc/tm-sparc.h: Update comment.
* hppa-tdep.c (hppa_init_extra_frame_info): Use
deprecated_read_fp instead of TARGET_READ_FP.
(hppa_init_extra_frame_info, hppa_frame_chain): Ditto.
(hppa_push_dummy_frame, hppa_read_fp): Ditto.
* sparc-tdep.c (sparc_init_extra_frame_info): Use
deprecated_read_fp instead of read_fp.
* s390-tdep.c (s390_push_arguments): Ditto.
* ia64-tdep.c (ia64_gdbarch_init): Ditto.
* frame.h: Ditto in comments.
* frame.c (legacy_get_prev_frame): Ditto.
* dummy-frame.c (dummy_frame_this_id): Ditto.
* arm-tdep.c (arm_init_extra_frame_info): Ditto.
2003-04-28 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Replace
read_fp, TARGET_READ_FP and FP_REGNUM, with deprecated_read_fp,
DEPRECATED_TARGET_READ_FP and DEPRECATED_REGNUM.
2003-04-29 03:49:49 +02:00
|
|
|
be necessary since the code should be getting the frame's base
|
|
|
|
correct from the outset.
|
2003-04-13 17:54:58 +02:00
|
|
|
|
|
|
|
This replaced: frame->frame = ....; */
|
2002-12-18 19:03:42 +01:00
|
|
|
extern void deprecated_update_frame_base_hack (struct frame_info *frame,
|
|
|
|
CORE_ADDR base);
|
2002-12-13 22:57:40 +01:00
|
|
|
|
2003-01-06 22:50:25 +01:00
|
|
|
/* FIXME: cagney/2003-01-05: Allocate a frame, along with the
|
|
|
|
saved_regs and extra_info. Set up cleanups for all three. Same as
|
|
|
|
for deprecated_frame_xmalloc, targets are calling this when
|
|
|
|
creating a scratch `struct frame_info'. The frame overhaul makes
|
|
|
|
this unnecessary since all frame queries are parameterized with a
|
|
|
|
common cache parameter and a frame. */
|
|
|
|
extern struct frame_info *deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs,
|
|
|
|
long sizeof_extra_info);
|
|
|
|
|
2003-03-13 19:09:30 +01:00
|
|
|
/* Return non-zero if the architecture is relying on legacy frame
|
|
|
|
code. */
|
|
|
|
extern int legacy_frame_p (struct gdbarch *gdbarch);
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
#endif /* !defined (FRAME_H) */
|