1998-12-08 Philippe De Muyter <phdm@macqel.be>
* config/xm-aix4.h (SIGWINCH_HANDLER): Function `aix_resize_window' must accept a signal number as parameter. * config/rs6000/xm-rs6000.h (SIGWINCH_HANDLER): Ditto. * utils.c (initialize_utils): Give a parameter to `SIGWINCH_HANDLER'. * inferior.h (register_valid): Variable's type is `SIGNED char', not `char'. * findvar.c (register_valid): Ditto. * defs.h (make_cleanup_func): Protect parameter list by `PARAMS'. * gdbthread.h (unbind_target_thread_vector): Likewise.
This commit is contained in:
parent
c4efea12c8
commit
ac95dc5eeb
6 changed files with 183 additions and 91 deletions
|
@ -1,3 +1,17 @@
|
|||
1998-12-08 Philippe De Muyter <phdm@macqel.be>
|
||||
|
||||
* config/xm-aix4.h (SIGWINCH_HANDLER): Function `aix_resize_window'
|
||||
must accept a signal number as parameter.
|
||||
* config/rs6000/xm-rs6000.h (SIGWINCH_HANDLER): Ditto.
|
||||
* utils.c (initialize_utils): Give a parameter to `SIGWINCH_HANDLER'.
|
||||
|
||||
* inferior.h (register_valid): Variable's type is `SIGNED char', not
|
||||
`char'.
|
||||
* findvar.c (register_valid): Ditto.
|
||||
|
||||
* defs.h (make_cleanup_func): Protect parameter list by `PARAMS'.
|
||||
* gdbthread.h (unbind_target_thread_vector): Likewise.
|
||||
|
||||
Tue Dec 8 15:09:44 1998 Edith Epstein <eepstein@sophia.cygnus.com>
|
||||
|
||||
Merged in m68k-linux patch from Andreas Schwab
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* Parameters for hosting on an RS6000, for GDB, the GNU debugger.
|
||||
Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
|
||||
Copyright 1986-87, 1989, 1991-96, 1998 Free Software Foundation, Inc.
|
||||
Contributed by IBM Corporation.
|
||||
|
||||
This file is part of GDB.
|
||||
|
@ -72,7 +72,7 @@ extern char *strdup PARAMS ((char *));
|
|||
/* Signal handler for SIGWINCH `window size changed'. */
|
||||
|
||||
#define SIGWINCH_HANDLER aix_resizewindow
|
||||
extern void aix_resizewindow PARAMS ((void));
|
||||
extern void aix_resizewindow PARAMS ((int));
|
||||
|
||||
/* This doesn't seem to be declared in any header file I can find. */
|
||||
char *termdef PARAMS ((int, int));
|
||||
|
@ -82,10 +82,11 @@ char *termdef PARAMS ((int, int));
|
|||
#define SIGWINCH_HANDLER_BODY \
|
||||
\
|
||||
/* Respond to SIGWINCH `window size changed' signal, and reset GDB's \
|
||||
window settings approproatelt. */ \
|
||||
window settings appropriately. */ \
|
||||
\
|
||||
void \
|
||||
aix_resizewindow () \
|
||||
aix_resizewindow (signo) \
|
||||
int signo; \
|
||||
{ \
|
||||
int fd = fileno (stdout); \
|
||||
if (isatty (fd)) { \
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* Parameters for hosting on an PowerPC, for GDB, the GNU debugger.
|
||||
Copyright 1995 Free Software Foundation, Inc.
|
||||
Copyright 1995, 1998 Free Software Foundation, Inc.
|
||||
Contributed by Cygnus Corporation.
|
||||
|
||||
This file is part of GDB.
|
||||
|
@ -16,7 +16,7 @@ GNU General Public License for more details.
|
|||
|
||||
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
||||
|
||||
/* The following text is taken from config/rs6000.mh:
|
||||
* # The IBM version of /usr/include/rpc/rpc.h has a bug -- it says
|
||||
|
@ -70,17 +70,18 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
/* Signal handler for SIGWINCH `window size changed'. */
|
||||
|
||||
#define SIGWINCH_HANDLER aix_resizewindow
|
||||
extern void aix_resizewindow PARAMS ((void));
|
||||
extern void aix_resizewindow PARAMS ((int));
|
||||
|
||||
/* `lines_per_page' and `chars_per_line' are local to utils.c. Rectify this. */
|
||||
|
||||
#define SIGWINCH_HANDLER_BODY \
|
||||
\
|
||||
/* Respond to SIGWINCH `window size changed' signal, and reset GDB's \
|
||||
window settings approproatelt. */ \
|
||||
window settings appropriately. */ \
|
||||
\
|
||||
void \
|
||||
aix_resizewindow () \
|
||||
aix_resizewindow (signo) \
|
||||
int signo; \
|
||||
{ \
|
||||
int fd = fileno (stdout); \
|
||||
if (isatty (fd)) { \
|
||||
|
|
|
@ -247,7 +247,7 @@ extern void discard_cleanups PARAMS ((struct cleanup *));
|
|||
extern void discard_final_cleanups PARAMS ((struct cleanup *));
|
||||
extern void discard_my_cleanups PARAMS ((struct cleanup **, struct cleanup *));
|
||||
|
||||
typedef void (*make_cleanup_func) (void *);
|
||||
typedef void (*make_cleanup_func) PARAMS ((void *));
|
||||
|
||||
extern struct cleanup *make_cleanup PARAMS ((make_cleanup_func, void *));
|
||||
|
||||
|
@ -286,10 +286,14 @@ extern void mfree PARAMS ((PTR, PTR));
|
|||
extern void set_demangling_style PARAMS ((char *));
|
||||
|
||||
/* From tm.h */
|
||||
|
||||
struct type;
|
||||
typedef int (use_struct_convention_fn) PARAMS ((int gcc_p, struct type *value_type));
|
||||
extern use_struct_convention_fn generic_use_struct_convention;
|
||||
|
||||
typedef unsigned char *(breakpoint_from_pc_fn) PARAMS ((CORE_ADDR *pcptr, int *lenptr));
|
||||
|
||||
|
||||
|
||||
/* Annotation stuff. */
|
||||
|
||||
|
|
220
gdb/findvar.c
220
gdb/findvar.c
|
@ -1,5 +1,6 @@
|
|||
/* Find a variable's value in memory, for GDB, the GNU debugger.
|
||||
Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996 Free Software Foundation, Inc.
|
||||
Copyright 1986, 87, 89, 91, 94, 95, 96, 1998
|
||||
Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GDB.
|
||||
|
||||
|
@ -27,6 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
|||
#include "target.h"
|
||||
#include "gdb_string.h"
|
||||
#include "floatformat.h"
|
||||
#include "symfile.h" /* for overlay functions */
|
||||
|
||||
/* This is used to indicate that we don't know the format of the floating point
|
||||
number. Typically, this is useful for native ports, where the actual format
|
||||
|
@ -39,7 +41,8 @@ const struct floatformat floatformat_unknown;
|
|||
#define CANNOT_STORE_REGISTER(regno) 0
|
||||
#endif
|
||||
|
||||
static void write_register_pid PARAMS ((int regno, LONGEST val, int pid));
|
||||
static void
|
||||
write_register_gen PARAMS ((int, char *));
|
||||
|
||||
/* Basic byte-swapping routines. GDB has needed these for a long time...
|
||||
All extract a target-format integer at ADDR which is LEN bytes long. */
|
||||
|
@ -88,20 +91,20 @@ That operation is not available on integers of more than %d bytes.",
|
|||
return retval;
|
||||
}
|
||||
|
||||
unsigned LONGEST
|
||||
ULONGEST
|
||||
extract_unsigned_integer (addr, len)
|
||||
PTR addr;
|
||||
int len;
|
||||
{
|
||||
unsigned LONGEST retval;
|
||||
ULONGEST retval;
|
||||
unsigned char *p;
|
||||
unsigned char *startaddr = (unsigned char *)addr;
|
||||
unsigned char *endaddr = startaddr + len;
|
||||
|
||||
if (len > (int) sizeof (unsigned LONGEST))
|
||||
if (len > (int) sizeof (ULONGEST))
|
||||
error ("\
|
||||
That operation is not available on integers of more than %d bytes.",
|
||||
sizeof (unsigned LONGEST));
|
||||
sizeof (ULONGEST));
|
||||
|
||||
/* Start at the most significant end of the integer, and work towards
|
||||
the least significant. */
|
||||
|
@ -215,7 +218,7 @@ void
|
|||
store_unsigned_integer (addr, len, val)
|
||||
PTR addr;
|
||||
int len;
|
||||
unsigned LONGEST val;
|
||||
ULONGEST val;
|
||||
{
|
||||
unsigned char *p;
|
||||
unsigned char *startaddr = (unsigned char *)addr;
|
||||
|
@ -271,21 +274,13 @@ store_address (addr, len, val)
|
|||
} \
|
||||
while (0)
|
||||
|
||||
/* There are various problems with the extract_floating and store_floating
|
||||
routines.
|
||||
/* Extract a floating-point number from a target-order byte-stream at ADDR.
|
||||
Returns the value as type DOUBLEST.
|
||||
|
||||
1. These routines only handle byte-swapping, not conversion of
|
||||
formats. So if host is IEEE floating and target is VAX floating,
|
||||
or vice-versa, it loses. This means that we can't (yet) use these
|
||||
routines for extendeds. Extendeds are handled by
|
||||
REGISTER_CONVERTIBLE. What we want is to use floatformat.h, but that
|
||||
doesn't yet handle VAX floating at all.
|
||||
|
||||
2. We can't deal with it if there is more than one floating point
|
||||
format in use. This has to be fixed at the unpack_double level.
|
||||
|
||||
3. We probably should have a LONGEST_DOUBLE or DOUBLEST or whatever
|
||||
we want to call it which is long double where available. */
|
||||
If the host and target formats agree, we just copy the raw data into the
|
||||
appropriate type of variable and return, letting the host increase precision
|
||||
as necessary. Otherwise, we call the conversion routine and let it do the
|
||||
dirty work. */
|
||||
|
||||
DOUBLEST
|
||||
extract_floating (addr, len)
|
||||
|
@ -304,7 +299,7 @@ extract_floating (addr, len)
|
|||
return retval;
|
||||
}
|
||||
else
|
||||
FLOATFORMAT_TO_DOUBLEST (TARGET_FLOAT_FORMAT, addr, &dretval);
|
||||
floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval);
|
||||
}
|
||||
else if (len == sizeof (double))
|
||||
{
|
||||
|
@ -316,7 +311,7 @@ extract_floating (addr, len)
|
|||
return retval;
|
||||
}
|
||||
else
|
||||
FLOATFORMAT_TO_DOUBLEST (TARGET_DOUBLE_FORMAT, addr, &dretval);
|
||||
floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval);
|
||||
}
|
||||
else if (len == sizeof (DOUBLEST))
|
||||
{
|
||||
|
@ -328,7 +323,7 @@ extract_floating (addr, len)
|
|||
return retval;
|
||||
}
|
||||
else
|
||||
FLOATFORMAT_TO_DOUBLEST (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval);
|
||||
floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -353,7 +348,7 @@ store_floating (addr, len, val)
|
|||
memcpy (addr, &floatval, sizeof (floatval));
|
||||
}
|
||||
else
|
||||
FLOATFORMAT_FROM_DOUBLEST (TARGET_FLOAT_FORMAT, &val, addr);
|
||||
floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr);
|
||||
}
|
||||
else if (len == sizeof (double))
|
||||
{
|
||||
|
@ -364,14 +359,14 @@ store_floating (addr, len, val)
|
|||
memcpy (addr, &doubleval, sizeof (doubleval));
|
||||
}
|
||||
else
|
||||
FLOATFORMAT_FROM_DOUBLEST (TARGET_DOUBLE_FORMAT, &val, addr);
|
||||
floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr);
|
||||
}
|
||||
else if (len == sizeof (DOUBLEST))
|
||||
{
|
||||
if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
|
||||
memcpy (addr, &val, sizeof (val));
|
||||
else
|
||||
FLOATFORMAT_FROM_DOUBLEST (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
|
||||
floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -535,12 +530,19 @@ read_relative_register_raw_bytes (regnum, myaddr)
|
|||
|
||||
get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, selected_frame,
|
||||
regnum, (enum lval_type *)NULL);
|
||||
|
||||
if (register_valid [regnum] < 0)
|
||||
return 1; /* register value not available */
|
||||
|
||||
return optim;
|
||||
}
|
||||
|
||||
/* Return a `value' with the contents of register REGNUM
|
||||
in its virtual format, with the type specified by
|
||||
REGISTER_VIRTUAL_TYPE. */
|
||||
REGISTER_VIRTUAL_TYPE.
|
||||
|
||||
NOTE: returns NULL if register value is not available.
|
||||
Caller will check return value or die! */
|
||||
|
||||
value_ptr
|
||||
value_of_register (regnum)
|
||||
|
@ -555,6 +557,9 @@ value_of_register (regnum)
|
|||
get_saved_register (raw_buffer, &optim, &addr,
|
||||
selected_frame, regnum, &lval);
|
||||
|
||||
if (register_valid[regnum] < 0)
|
||||
return NULL; /* register value not available */
|
||||
|
||||
reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
|
||||
|
||||
/* Convert raw data to virtual format if necessary. */
|
||||
|
@ -567,8 +572,13 @@ value_of_register (regnum)
|
|||
}
|
||||
else
|
||||
#endif
|
||||
if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
|
||||
memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
|
||||
REGISTER_RAW_SIZE (regnum));
|
||||
else
|
||||
fatal ("Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
|
||||
reg_names [regnum], regnum,
|
||||
REGISTER_RAW_SIZE (regnum), REGISTER_VIRTUAL_SIZE (regnum));
|
||||
VALUE_LVAL (reg_val) = lval;
|
||||
VALUE_ADDRESS (reg_val) = addr;
|
||||
VALUE_REGNO (reg_val) = regnum;
|
||||
|
@ -584,12 +594,14 @@ value_of_register (regnum)
|
|||
the caller got the value from the last stop). */
|
||||
|
||||
/* Contents of the registers in target byte order.
|
||||
We allocate some extra slop since we do a lot of memcpy's around `registers',
|
||||
and failing-soft is better than failing hard. */
|
||||
We allocate some extra slop since we do a lot of memcpy's around
|
||||
`registers', and failing-soft is better than failing hard. */
|
||||
|
||||
char registers[REGISTER_BYTES + /* SLOP */ 256];
|
||||
|
||||
/* Nonzero if that register has been fetched. */
|
||||
char register_valid[NUM_REGS];
|
||||
/* Nonzero if that register has been fetched,
|
||||
-1 if register value not available. */
|
||||
SIGNED char register_valid[NUM_REGS];
|
||||
|
||||
/* The thread/process associated with the current set of registers. For now,
|
||||
-1 is special, and means `no current process'. */
|
||||
|
@ -605,6 +617,13 @@ registers_changed ()
|
|||
|
||||
registers_pid = -1;
|
||||
|
||||
/* Force cleanup of any alloca areas if using C alloca instead of
|
||||
a builtin alloca. This particular call is used to clean up
|
||||
areas allocated by low level target code which may build up
|
||||
during lengthy interactions between gdb and the target before
|
||||
gdb gives control to the user (ie watchpoints). */
|
||||
alloca (0);
|
||||
|
||||
for (i = 0; i < numregs; i++)
|
||||
register_valid[i] = 0;
|
||||
|
||||
|
@ -667,6 +686,9 @@ read_register_bytes (inregbyte, myaddr, inlen)
|
|||
if (register_valid[regno])
|
||||
continue;
|
||||
|
||||
if (reg_names[regno] == NULL || *reg_names[regno] == '\0')
|
||||
continue;
|
||||
|
||||
regstart = REGISTER_BYTE (regno);
|
||||
regend = regstart + REGISTER_RAW_SIZE (regno);
|
||||
|
||||
|
@ -713,7 +735,7 @@ read_register_gen (regno, myaddr)
|
|||
/* Write register REGNO at MYADDR to the target. MYADDR points at
|
||||
REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
|
||||
|
||||
void
|
||||
static void
|
||||
write_register_gen (regno, myaddr)
|
||||
int regno;
|
||||
char *myaddr;
|
||||
|
@ -747,6 +769,9 @@ write_register_gen (regno, myaddr)
|
|||
register_valid [regno] = 1;
|
||||
|
||||
target_store_registers (regno);
|
||||
|
||||
if (regno == PC_REGNUM && pc_changed_hook)
|
||||
pc_changed_hook ();
|
||||
}
|
||||
|
||||
/* Copy INLEN bytes of consecutive data from memory at MYADDR
|
||||
|
@ -887,7 +912,7 @@ write_register (regno, val)
|
|||
target_store_registers (regno);
|
||||
}
|
||||
|
||||
static void
|
||||
void
|
||||
write_register_pid (regno, val, pid)
|
||||
int regno;
|
||||
LONGEST val;
|
||||
|
@ -912,21 +937,31 @@ write_register_pid (regno, val, pid)
|
|||
|
||||
/* Record that register REGNO contains VAL.
|
||||
This is used when the value is obtained from the inferior or core dump,
|
||||
so there is no need to store the value there. */
|
||||
so there is no need to store the value there.
|
||||
|
||||
If VAL is a NULL pointer, then it's probably an unsupported register. We
|
||||
just set it's value to all zeros. We might want to record this fact, and
|
||||
report it to the users of read_register and friends.
|
||||
*/
|
||||
|
||||
void
|
||||
supply_register (regno, val)
|
||||
int regno;
|
||||
char *val;
|
||||
{
|
||||
#if 1
|
||||
if (registers_pid != inferior_pid)
|
||||
{
|
||||
registers_changed ();
|
||||
registers_pid = inferior_pid;
|
||||
}
|
||||
#endif
|
||||
|
||||
register_valid[regno] = 1;
|
||||
if (val)
|
||||
memcpy (®isters[REGISTER_BYTE (regno)], val, REGISTER_RAW_SIZE (regno));
|
||||
else
|
||||
memset (®isters[REGISTER_BYTE (regno)], '\000', REGISTER_RAW_SIZE (regno));
|
||||
|
||||
/* On some architectures, e.g. HPPA, there are a few stray bits in some
|
||||
registers, that the rest of the code would like to ignore. */
|
||||
|
@ -940,16 +975,6 @@ supply_register (regno, val)
|
|||
time to turn this into READ_PC and define it in the tm.h file.
|
||||
Ditto for write_pc. */
|
||||
|
||||
CORE_ADDR
|
||||
read_pc ()
|
||||
{
|
||||
#ifdef TARGET_READ_PC
|
||||
return TARGET_READ_PC (inferior_pid);
|
||||
#else
|
||||
return ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, inferior_pid));
|
||||
#endif
|
||||
}
|
||||
|
||||
CORE_ADDR
|
||||
read_pc_pid (pid)
|
||||
int pid;
|
||||
|
@ -961,39 +986,35 @@ read_pc_pid (pid)
|
|||
#endif
|
||||
}
|
||||
|
||||
CORE_ADDR
|
||||
read_pc ()
|
||||
{
|
||||
return read_pc_pid (inferior_pid);
|
||||
}
|
||||
|
||||
void
|
||||
write_pc (val)
|
||||
CORE_ADDR val;
|
||||
write_pc_pid (pc, pid)
|
||||
CORE_ADDR pc;
|
||||
int pid;
|
||||
{
|
||||
#ifdef TARGET_WRITE_PC
|
||||
TARGET_WRITE_PC (val, inferior_pid);
|
||||
TARGET_WRITE_PC (pc, pid);
|
||||
#else
|
||||
write_register_pid (PC_REGNUM, val, inferior_pid);
|
||||
write_register_pid (PC_REGNUM, pc, pid);
|
||||
#ifdef NPC_REGNUM
|
||||
write_register_pid (NPC_REGNUM, val + 4, inferior_pid);
|
||||
write_register_pid (NPC_REGNUM, pc + 4, pid);
|
||||
#ifdef NNPC_REGNUM
|
||||
write_register_pid (NNPC_REGNUM, val + 8, inferior_pid);
|
||||
write_register_pid (NNPC_REGNUM, pc + 8, pid);
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
write_pc_pid (val, pid)
|
||||
CORE_ADDR val;
|
||||
int pid;
|
||||
write_pc (pc)
|
||||
CORE_ADDR pc;
|
||||
{
|
||||
#ifdef TARGET_WRITE_PC
|
||||
TARGET_WRITE_PC (val, pid);
|
||||
#else
|
||||
write_register_pid (PC_REGNUM, val, pid);
|
||||
#ifdef NPC_REGNUM
|
||||
write_register_pid (NPC_REGNUM, val + 4, pid);
|
||||
#ifdef NNPC_REGNUM
|
||||
write_register_pid (NNPC_REGNUM, val + 8, pid);
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
write_pc_pid (pc, inferior_pid);
|
||||
}
|
||||
|
||||
/* Cope with strage ways of getting to the stack and frame pointers */
|
||||
|
@ -1099,6 +1120,8 @@ read_var_value (var, frame)
|
|||
|
||||
v = allocate_value (type);
|
||||
VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
|
||||
VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
|
||||
|
||||
len = TYPE_LENGTH (type);
|
||||
|
||||
if (frame == NULL) frame = selected_frame;
|
||||
|
@ -1114,7 +1137,13 @@ read_var_value (var, frame)
|
|||
|
||||
case LOC_LABEL:
|
||||
/* Put the constant back in target format. */
|
||||
store_address (VALUE_CONTENTS_RAW (v), len, SYMBOL_VALUE_ADDRESS (var));
|
||||
if (overlay_debugging)
|
||||
store_address (VALUE_CONTENTS_RAW (v), len,
|
||||
symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
|
||||
SYMBOL_BFD_SECTION (var)));
|
||||
else
|
||||
store_address (VALUE_CONTENTS_RAW (v), len,
|
||||
SYMBOL_VALUE_ADDRESS (var));
|
||||
VALUE_LVAL (v) = not_lval;
|
||||
return v;
|
||||
|
||||
|
@ -1128,6 +1157,10 @@ read_var_value (var, frame)
|
|||
}
|
||||
|
||||
case LOC_STATIC:
|
||||
if (overlay_debugging)
|
||||
addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
|
||||
SYMBOL_BFD_SECTION (var));
|
||||
else
|
||||
addr = SYMBOL_VALUE_ADDRESS (var);
|
||||
break;
|
||||
|
||||
|
@ -1175,6 +1208,10 @@ read_var_value (var, frame)
|
|||
break;
|
||||
|
||||
case LOC_BLOCK:
|
||||
if (overlay_debugging)
|
||||
VALUE_ADDRESS (v) = symbol_overlayed_address
|
||||
(BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
|
||||
else
|
||||
VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
|
||||
return v;
|
||||
|
||||
|
@ -1183,22 +1220,33 @@ read_var_value (var, frame)
|
|||
case LOC_REGPARM_ADDR:
|
||||
{
|
||||
struct block *b;
|
||||
int regno = SYMBOL_VALUE (var);
|
||||
value_ptr regval;
|
||||
|
||||
if (frame == NULL)
|
||||
return 0;
|
||||
b = get_frame_block (frame);
|
||||
|
||||
|
||||
if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
|
||||
{
|
||||
addr =
|
||||
value_as_pointer (value_from_register (lookup_pointer_type (type),
|
||||
SYMBOL_VALUE (var),
|
||||
frame));
|
||||
regval = value_from_register (lookup_pointer_type (type),
|
||||
regno,
|
||||
frame);
|
||||
|
||||
if (regval == NULL)
|
||||
error ("Value of register variable not available.");
|
||||
|
||||
addr = value_as_pointer (regval);
|
||||
VALUE_LVAL (v) = lval_memory;
|
||||
}
|
||||
else
|
||||
return value_from_register (type, SYMBOL_VALUE (var), frame);
|
||||
{
|
||||
regval = value_from_register (type, regno, frame);
|
||||
|
||||
if (regval == NULL)
|
||||
error ("Value of register variable not available.");
|
||||
return regval;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
|
@ -1209,6 +1257,10 @@ read_var_value (var, frame)
|
|||
msym = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
|
||||
if (msym == NULL)
|
||||
return 0;
|
||||
if (overlay_debugging)
|
||||
addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
|
||||
SYMBOL_BFD_SECTION (msym));
|
||||
else
|
||||
addr = SYMBOL_VALUE_ADDRESS (msym);
|
||||
}
|
||||
break;
|
||||
|
@ -1229,7 +1281,10 @@ read_var_value (var, frame)
|
|||
}
|
||||
|
||||
/* Return a value of type TYPE, stored in register REGNUM, in frame
|
||||
FRAME. */
|
||||
FRAME.
|
||||
|
||||
NOTE: returns NULL if register value is not available.
|
||||
Caller will check return value or die! */
|
||||
|
||||
value_ptr
|
||||
value_from_register (type, regnum, frame)
|
||||
|
@ -1308,6 +1363,9 @@ value_from_register (type, regnum, frame)
|
|||
page_regnum,
|
||||
&lval);
|
||||
|
||||
if (register_valid[page_regnum] == -1)
|
||||
return NULL; /* register value not available */
|
||||
|
||||
if (lval == lval_register)
|
||||
reg_stor++;
|
||||
else
|
||||
|
@ -1322,6 +1380,9 @@ value_from_register (type, regnum, frame)
|
|||
regnum,
|
||||
&lval);
|
||||
|
||||
if (register_valid[regnum] == -1)
|
||||
return NULL; /* register value not available */
|
||||
|
||||
if (lval == lval_register)
|
||||
reg_stor++;
|
||||
else
|
||||
|
@ -1345,6 +1406,9 @@ value_from_register (type, regnum, frame)
|
|||
local_regnum,
|
||||
&lval);
|
||||
|
||||
if (register_valid[local_regnum] == -1)
|
||||
return NULL; /* register value not available */
|
||||
|
||||
if (regnum == local_regnum)
|
||||
first_addr = addr;
|
||||
if (lval == lval_register)
|
||||
|
@ -1406,6 +1470,10 @@ value_from_register (type, regnum, frame)
|
|||
read the data in raw format. */
|
||||
|
||||
get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
|
||||
|
||||
if (register_valid[regnum] == -1)
|
||||
return NULL; /* register value not available */
|
||||
|
||||
VALUE_OPTIMIZED_OUT (v) = optim;
|
||||
VALUE_LVAL (v) = lval;
|
||||
VALUE_ADDRESS (v) = addr;
|
||||
|
@ -1459,8 +1527,12 @@ locate_var_value (var, frame)
|
|||
if (VALUE_LAZY (lazy_value)
|
||||
|| TYPE_CODE (type) == TYPE_CODE_FUNC)
|
||||
{
|
||||
value_ptr val;
|
||||
|
||||
addr = VALUE_ADDRESS (lazy_value);
|
||||
return value_from_longest (lookup_pointer_type (type), (LONGEST) addr);
|
||||
val = value_from_longest (lookup_pointer_type (type), (LONGEST) addr);
|
||||
VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
|
||||
return val;
|
||||
}
|
||||
|
||||
/* Not a memory address; check what the problem was. */
|
||||
|
|
|
@ -105,7 +105,7 @@ struct target_thread_vector
|
|||
|
||||
extern void bind_target_thread_vector PARAMS((struct target_thread_vector * vec)) ;
|
||||
|
||||
extern struct target_thread_vector * unbind_target_thread_vector(void) ;
|
||||
extern struct target_thread_vector * unbind_target_thread_vector PARAMS ((void)) ;
|
||||
|
||||
extern int target_get_thread_info PARAMS((
|
||||
gdb_threadref * ref,
|
||||
|
|
Loading…
Reference in a new issue