1 /* Cache and manage the values of registers for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
26 #include "inferior.h" /* for inferior_ptid */
29 /* FIND_SAVED_REGISTER ()
31 Return the address in which frame FRAME's value of register REGNUM
32 has been saved in memory. Or return zero if it has not been saved.
33 If REGNUM specifies the SP, the value we return is actually
34 the SP value, not an address where it was saved. */
37 find_saved_register (struct frame_info
*frame
, int regnum
)
39 register struct frame_info
*frame1
= NULL
;
40 register CORE_ADDR addr
= 0;
42 if (frame
== NULL
) /* No regs saved if want current frame */
45 #ifdef HAVE_REGISTER_WINDOWS
46 /* We assume that a register in a register window will only be saved
47 in one place (since the name changes and/or disappears as you go
48 towards inner frames), so we only call get_frame_saved_regs on
49 the current frame. This is directly in contradiction to the
50 usage below, which assumes that registers used in a frame must be
51 saved in a lower (more interior) frame. This change is a result
52 of working on a register window machine; get_frame_saved_regs
53 always returns the registers saved within a frame, within the
54 context (register namespace) of that frame. */
56 /* However, note that we don't want this to return anything if
57 nothing is saved (if there's a frame inside of this one). Also,
58 callers to this routine asking for the stack pointer want the
59 stack pointer saved for *this* frame; this is returned from the
62 if (REGISTER_IN_WINDOW_P (regnum
))
64 frame1
= get_next_frame (frame
);
66 return 0; /* Registers of this frame are active. */
68 /* Get the SP from the next frame in; it will be this
70 if (regnum
!= SP_REGNUM
)
73 FRAME_INIT_SAVED_REGS (frame1
);
74 return frame1
->saved_regs
[regnum
]; /* ... which might be zero */
76 #endif /* HAVE_REGISTER_WINDOWS */
78 /* Note that this next routine assumes that registers used in
79 frame x will be saved only in the frame that x calls and
80 frames interior to it. This is not true on the sparc, but the
81 above macro takes care of it, so we should be all right. */
85 frame1
= get_prev_frame (frame1
);
86 if (frame1
== 0 || frame1
== frame
)
88 FRAME_INIT_SAVED_REGS (frame1
);
89 if (frame1
->saved_regs
[regnum
])
90 addr
= frame1
->saved_regs
[regnum
];
96 /* DEFAULT_GET_SAVED_REGISTER ()
98 Find register number REGNUM relative to FRAME and put its (raw,
99 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
100 variable was optimized out (and thus can't be fetched). Set *LVAL
101 to lval_memory, lval_register, or not_lval, depending on whether
102 the value was fetched from memory, from a register, or in a strange
103 and non-modifiable way (e.g. a frame pointer which was calculated
104 rather than fetched). Set *ADDRP to the address, either in memory
105 on as a REGISTER_BYTE offset into the registers array.
107 Note that this implementation never sets *LVAL to not_lval. But
108 it can be replaced by defining GET_SAVED_REGISTER and supplying
111 The argument RAW_BUFFER must point to aligned memory. */
114 default_get_saved_register (char *raw_buffer
,
117 struct frame_info
*frame
,
119 enum lval_type
*lval
)
123 if (!target_has_registers
)
124 error ("No registers.");
126 /* Normal systems don't optimize out things with register numbers. */
127 if (optimized
!= NULL
)
129 addr
= find_saved_register (frame
, regnum
);
134 if (regnum
== SP_REGNUM
)
136 if (raw_buffer
!= NULL
)
138 /* Put it back in target format. */
139 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
146 if (raw_buffer
!= NULL
)
147 target_read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
152 *lval
= lval_register
;
153 addr
= REGISTER_BYTE (regnum
);
154 if (raw_buffer
!= NULL
)
155 read_register_gen (regnum
, raw_buffer
);
161 #if !defined (GET_SAVED_REGISTER)
162 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
163 default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
167 get_saved_register (char *raw_buffer
,
170 struct frame_info
*frame
,
172 enum lval_type
*lval
)
174 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
177 /* READ_RELATIVE_REGISTER_RAW_BYTES_FOR_FRAME
179 Copy the bytes of register REGNUM, relative to the input stack frame,
180 into our memory at MYADDR, in target byte order.
181 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
183 Returns 1 if could not be read, 0 if could. */
185 /* FIXME: This function increases the confusion between FP_REGNUM
186 and the virtual/pseudo-frame pointer. */
189 read_relative_register_raw_bytes_for_frame (int regnum
,
191 struct frame_info
*frame
)
194 if (regnum
== FP_REGNUM
&& frame
)
196 /* Put it back in target format. */
197 store_address (myaddr
, REGISTER_RAW_SIZE (FP_REGNUM
),
198 (LONGEST
) FRAME_FP (frame
));
203 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, frame
,
204 regnum
, (enum lval_type
*) NULL
);
206 if (register_cached (regnum
) < 0)
207 return 1; /* register value not available */
212 /* READ_RELATIVE_REGISTER_RAW_BYTES
214 Copy the bytes of register REGNUM, relative to the current stack
215 frame, into our memory at MYADDR, in target byte order.
216 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
218 Returns 1 if could not be read, 0 if could. */
221 read_relative_register_raw_bytes (int regnum
, char *myaddr
)
223 return read_relative_register_raw_bytes_for_frame (regnum
, myaddr
,
This page took 0.033052 seconds and 4 git commands to generate.