OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* frame.c (get_frame_register_bytes): New function. 

(put_frame_register_bytes): Likewise.
	* frame.h (get_frame_register_bytes): Declare.
	(put_frame_register_bytes): Likewise.
	* findvar.c (value_from_register): Always construct lval_register
	values.  Use get_frame_register_bytes.
	* valops.c (value_assign): Use get_frame_register_bytes and
	put_frame_register_bytes.
This commit is contained in:
Ulrich Weigand 2007-01-08 17:34:12 +00:00
parent 42037fe5bb
commit 00fa51f680
5 changed files with 146 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
gdb/ChangeLog
View File

@ -1,3 +1,14 @@
2007-01-08 Ulrich Weigand <uweigand@de.ibm.com>
* frame.c (get_frame_register_bytes): New function.
(put_frame_register_bytes): Likewise.
* frame.h (get_frame_register_bytes): Declare.
(put_frame_register_bytes): Likewise.
* findvar.c (value_from_register): Always construct lval_register
values. Use get_frame_register_bytes.
* valops.c (value_assign): Use get_frame_register_bytes and
put_frame_register_bytes.
2007-01-08 Jim Blandy <jimb@codesourcery.com>
* MAINTAINERS: Update Stan Shebs' email address.

108
gdb/findvar.c
View File

@ -599,11 +599,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i
return v;
}
/* Return a value of type TYPE, stored in register REGNUM, in frame
FRAME.
NOTE: returns NULL if register value is not available.
Caller will check return value or die! */
/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
struct value *
value_from_register (struct type *type, int regnum, struct frame_info *frame)
@ -612,30 +608,11 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
struct value *v = allocate_value (type);
CHECK_TYPEDEF (type);
if (TYPE_LENGTH (type) == 0)
{
/* It doesn't matter much what we return for this: since the
length is zero, it could be anything. But if allowed to see
a zero-length type, the register-finding loop below will set
neither mem_stor nor reg_stor, and then report an internal
error.
Zero-length types can legitimately arise from declarations
like 'struct {}' (a GCC extension, not valid ISO C). GDB may
also create them when it finds bogus debugging information;
for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the
STABS BINCL->EXCL compression process can create bad type
numbers. GDB reads these as TYPE_CODE_UNDEF types, with zero
length. (That bug is actually the only known way to get a
zero-length value allocated to a register --- which is what
it takes to make it here.)
We'll just attribute the value to the original register. */
VALUE_LVAL (v) = lval_register;
VALUE_ADDRESS (v) = regnum;
VALUE_REGNUM (v) = regnum;
}
else if (CONVERT_REGISTER_P (regnum, type))
VALUE_LVAL (v) = lval_register;
VALUE_FRAME_ID (v) = get_frame_id (frame);
VALUE_REGNUM (v) = regnum;
if (CONVERT_REGISTER_P (regnum, type))
{
/* The ISA/ABI need to something weird when obtaining the
specified value from this register. It might need to
@ -645,85 +622,26 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
is that REGISTER_TO_VALUE populates the entire value
including the location. */
REGISTER_TO_VALUE (frame, regnum, type, value_contents_raw (v));
VALUE_LVAL (v) = lval_register;
VALUE_FRAME_ID (v) = get_frame_id (frame);
VALUE_REGNUM (v) = regnum;
}
else
{
int local_regnum;
int mem_stor = 0, reg_stor = 0;
int mem_tracking = 1;
CORE_ADDR last_addr = 0;
CORE_ADDR first_addr = 0;
int first_realnum = regnum;
int len = TYPE_LENGTH (type);
int value_bytes_copied;
int optimized = 0;
gdb_byte *value_bytes = alloca (len + MAX_REGISTER_SIZE);
/* Copy all of the data out, whereever it may be. */
for (local_regnum = regnum, value_bytes_copied = 0;
value_bytes_copied < len;
(value_bytes_copied += register_size (current_gdbarch, local_regnum),
++local_regnum))
{
int realnum;
int optim;
enum lval_type lval;
CORE_ADDR addr;
frame_register (frame, local_regnum, &optim, &lval, &addr,
&realnum, value_bytes + value_bytes_copied);
optimized += optim;
if (register_cached (local_regnum) == -1)
return NULL; /* register value not available */
if (regnum == local_regnum)
{
first_addr = addr;
first_realnum = realnum;
}
if (lval == lval_register)
reg_stor++;
else
{
mem_stor++;
/* FIXME: cagney/2004-11-12: I think this is trying to
check that the stored registers are adjacent in
memory. It isn't doing a good job? */
mem_tracking = (mem_tracking
&& (regnum == local_regnum
|| addr == last_addr));
}
last_addr = addr;
}
if (mem_tracking && mem_stor && !reg_stor)
{
VALUE_LVAL (v) = lval_memory;
VALUE_ADDRESS (v) = first_addr;
}
else
{
VALUE_LVAL (v) = lval_register;
VALUE_FRAME_ID (v) = get_frame_id (frame);
VALUE_REGNUM (v) = regnum;
}
set_value_optimized_out (v, optimized);
/* Any structure stored in more than one register will always be
an integral number of registers. Otherwise, you need to do
some fiddling with the last register copied here for little
endian machines. */
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
&& len < register_size (current_gdbarch, regnum))
&& len < register_size (gdbarch, regnum))
/* Big-endian, and we want less than full size. */
set_value_offset (v, register_size (current_gdbarch, regnum) - len);
set_value_offset (v, register_size (gdbarch, regnum) - len);
else
set_value_offset (v, 0);
memcpy (value_contents_raw (v), value_bytes + value_offset (v), len);
/* Get the data. */
if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
value_contents_raw (v)))
set_value_optimized_out (v, 1);
}
return v;
}

78
gdb/frame.c
View File

@ -742,6 +742,84 @@ frame_register_read (struct frame_info *frame, int regnum,
return !optimized;
}
int
get_frame_register_bytes (struct frame_info *frame, int regnum,
CORE_ADDR offset, int len, gdb_byte *myaddr)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
/* Skip registers wholly inside of OFFSET. */
while (offset >= register_size (gdbarch, regnum))
{
offset -= register_size (gdbarch, regnum);
regnum++;
}
/* Copy the data. */
while (len > 0)
{
int curr_len = register_size (gdbarch, regnum) - offset;
if (curr_len > len)
curr_len = len;
if (curr_len == register_size (gdbarch, regnum))
{
if (!frame_register_read (frame, regnum, myaddr))
return 0;
}
else
{
gdb_byte buf[MAX_REGISTER_SIZE];
if (!frame_register_read (frame, regnum, buf))
return 0;
memcpy (myaddr, buf + offset, curr_len);
}
len -= curr_len;
offset = 0;
regnum++;
}
return 1;
}
void
put_frame_register_bytes (struct frame_info *frame, int regnum,
CORE_ADDR offset, int len, const gdb_byte *myaddr)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
/* Skip registers wholly inside of OFFSET. */
while (offset >= register_size (gdbarch, regnum))
{
offset -= register_size (gdbarch, regnum);
regnum++;
}
/* Copy the data. */
while (len > 0)
{
int curr_len = register_size (gdbarch, regnum) - offset;
if (curr_len > len)
curr_len = len;
if (curr_len == register_size (gdbarch, regnum))
{
put_frame_register (frame, regnum, myaddr);
}
else
{
gdb_byte buf[MAX_REGISTER_SIZE];
frame_register_read (frame, regnum, buf);
memcpy (buf + offset, myaddr, curr_len);
put_frame_register (frame, regnum, buf);
}
len -= curr_len;
offset = 0;
regnum++;
}
}
/* Map between a frame register number and its name. A frame register
space is a superset of the cooked register space --- it also

12
gdb/frame.h
View File

@ -491,6 +491,18 @@ extern void frame_register (struct frame_info *frame, int regnum,
extern void put_frame_register (struct frame_info *frame, int regnum,
const gdb_byte *buf);
/* Read LEN bytes from one or multiple registers starting with REGNUM
in frame FRAME, starting at OFFSET, into BUF. */
extern int get_frame_register_bytes (struct frame_info *frame, int regnum,
CORE_ADDR offset, int len,
gdb_byte *myaddr);
/* Write LEN bytes to one or multiple registers starting with REGNUM
in frame FRAME, starting at OFFSET, into BUF. */
extern void put_frame_register_bytes (struct frame_info *frame, int regnum,
CORE_ADDR offset, int len,
const gdb_byte *myaddr);
/* Map between a frame register number and its name. A frame register
space is a superset of the cooked register space --- it also
includes builtin registers. If NAMELEN is negative, use the NAME's

84
gdb/valops.c
View File

@ -651,8 +651,7 @@ value_assign (struct value *toval, struct value *fromval)
if (!frame)
error (_("Value being assigned to is no longer active."));
if (VALUE_LVAL (toval) == lval_register
&& CONVERT_REGISTER_P (VALUE_REGNUM (toval), type))
if (CONVERT_REGISTER_P (VALUE_REGNUM (toval), type))
{
/* If TOVAL is a special machine register requiring
conversion of program values to a special raw format. */
@ -661,59 +660,40 @@ value_assign (struct value *toval, struct value *fromval)
}
else
{
/* TOVAL is stored in a series of registers in the frame
specified by the structure. Copy that value out,
modify it, and copy it back in. */
int amount_copied;
int amount_to_copy;
gdb_byte *buffer;
int reg_offset;
int byte_offset;
int regno;
/* Locate the first register that falls in the value that
needs to be transfered. Compute the offset of the
value in that register. */
{
int offset;
for (reg_offset = value_reg, offset = 0;
offset + register_size (current_gdbarch, reg_offset) <= value_offset (toval);
reg_offset++);
byte_offset = value_offset (toval) - offset;
}
/* Compute the number of register aligned values that need
to be copied. */
if (value_bitsize (toval))
amount_to_copy = byte_offset + 1;
{
int changed_len;
gdb_byte buffer[sizeof (LONGEST)];
changed_len = (value_bitpos (toval)
+ value_bitsize (toval)
+ HOST_CHAR_BIT - 1)
/ HOST_CHAR_BIT;
if (changed_len > (int) sizeof (LONGEST))
error (_("Can't handle bitfields which don't fit in a %d bit word."),
(int) sizeof (LONGEST) * HOST_CHAR_BIT);
get_frame_register_bytes (frame, value_reg,
value_offset (toval),
changed_len, buffer);
modify_field (buffer, value_as_long (fromval),
value_bitpos (toval), value_bitsize (toval));
put_frame_register_bytes (frame, value_reg,
value_offset (toval),
changed_len, buffer);
}
else
amount_to_copy = byte_offset + TYPE_LENGTH (type);
/* And a bounce buffer. Be slightly over generous. */
buffer = alloca (amount_to_copy + MAX_REGISTER_SIZE);
/* Copy it in. */
for (regno = reg_offset, amount_copied = 0;
amount_copied < amount_to_copy;
amount_copied += register_size (current_gdbarch, regno), regno++)
frame_register_read (frame, regno, buffer + amount_copied);
/* Modify what needs to be modified. */
if (value_bitsize (toval))
modify_field (buffer + byte_offset,
value_as_long (fromval),
value_bitpos (toval), value_bitsize (toval));
else
memcpy (buffer + byte_offset, value_contents (fromval),
TYPE_LENGTH (type));
/* Copy it out. */
for (regno = reg_offset, amount_copied = 0;
amount_copied < amount_to_copy;
amount_copied += register_size (current_gdbarch, regno), regno++)
put_frame_register (frame, regno, buffer + amount_copied);
{
put_frame_register_bytes (frame, value_reg,
value_offset (toval),
TYPE_LENGTH (type),
value_contents (fromval));
}
}
if (deprecated_register_changed_hook)
deprecated_register_changed_hook (-1);
observer_notify_target_changed (&current_target);