Various cleanups in target read/write code
This contains various cleanups in the target memory read and write code. They are not directly related to the non-8-bits changes, but they clarify things a bit down the line. gdb/ChangeLog: * target.c (target_read): Rename variables and use TARGET_XFER_E_IO. (target_read_with_progress): Same. (read_memory_robust): Constify parameters and rename variables. (read_whatever_is_readable): Constify parameters, rename variables, adjust formatting. * target.h (read_memory_robust): Constify parameters.
This commit is contained in:
parent
aaa9dc0170
commit
279a6fed95
3 changed files with 60 additions and 47 deletions
|
@ -1,3 +1,14 @@
|
|||
2015-06-12 Simon Marchi <simon.marchi@ericsson.com>
|
||||
|
||||
* target.c (target_read): Rename variables and use
|
||||
TARGET_XFER_E_IO.
|
||||
(target_read_with_progress): Same.
|
||||
(read_memory_robust): Constify parameters and rename
|
||||
variables.
|
||||
(read_whatever_is_readable): Constify parameters,
|
||||
rename variables, adjust formatting.
|
||||
* target.h (read_memory_robust): Constify parameters.
|
||||
|
||||
2015-05-12 Ulrich Weigand <uweigand@de.ibm.com>
|
||||
|
||||
* ppc-sysv-tdep.c (ppc64_sysv_abi_return_value_base): Handle short
|
||||
|
|
84
gdb/target.c
84
gdb/target.c
|
@ -1592,28 +1592,28 @@ target_read (struct target_ops *ops,
|
|||
const char *annex, gdb_byte *buf,
|
||||
ULONGEST offset, LONGEST len)
|
||||
{
|
||||
LONGEST xfered = 0;
|
||||
LONGEST xfered_total = 0;
|
||||
|
||||
while (xfered < len)
|
||||
while (xfered_total < len)
|
||||
{
|
||||
ULONGEST xfered_len;
|
||||
ULONGEST xfered_partial;
|
||||
enum target_xfer_status status;
|
||||
|
||||
status = target_read_partial (ops, object, annex,
|
||||
(gdb_byte *) buf + xfered,
|
||||
offset + xfered, len - xfered,
|
||||
&xfered_len);
|
||||
buf + xfered_total,
|
||||
offset + xfered_total, len - xfered_total,
|
||||
&xfered_partial);
|
||||
|
||||
/* Call an observer, notifying them of the xfer progress? */
|
||||
if (status == TARGET_XFER_EOF)
|
||||
return xfered;
|
||||
return xfered_total;
|
||||
else if (status == TARGET_XFER_OK)
|
||||
{
|
||||
xfered += xfered_len;
|
||||
xfered_total += xfered_partial;
|
||||
QUIT;
|
||||
}
|
||||
else
|
||||
return -1;
|
||||
return TARGET_XFER_E_IO;
|
||||
|
||||
}
|
||||
return len;
|
||||
|
@ -1642,7 +1642,7 @@ target_read (struct target_ops *ops,
|
|||
|
||||
static void
|
||||
read_whatever_is_readable (struct target_ops *ops,
|
||||
ULONGEST begin, ULONGEST end,
|
||||
const ULONGEST begin, const ULONGEST end,
|
||||
VEC(memory_read_result_s) **result)
|
||||
{
|
||||
gdb_byte *buf = xmalloc (end - begin);
|
||||
|
@ -1723,7 +1723,7 @@ read_whatever_is_readable (struct target_ops *ops,
|
|||
else
|
||||
{
|
||||
/* This half is not readable. Because we've tried one byte, we
|
||||
know some part of this half if actually redable. Go to the next
|
||||
know some part of this half if actually readable. Go to the next
|
||||
iteration to divide again and try to read.
|
||||
|
||||
We don't handle the other half, because this function only tries
|
||||
|
@ -1743,10 +1743,10 @@ read_whatever_is_readable (struct target_ops *ops,
|
|||
else
|
||||
{
|
||||
/* The [current_end, end) range has been read. */
|
||||
LONGEST rlen = end - current_end;
|
||||
LONGEST region_len = end - current_end;
|
||||
|
||||
r.data = xmalloc (rlen);
|
||||
memcpy (r.data, buf + current_end - begin, rlen);
|
||||
r.data = xmalloc (region_len);
|
||||
memcpy (r.data, buf + current_end - begin, region_len);
|
||||
r.begin = current_end;
|
||||
r.end = end;
|
||||
xfree (buf);
|
||||
|
@ -1769,57 +1769,59 @@ free_memory_read_result_vector (void *x)
|
|||
}
|
||||
|
||||
VEC(memory_read_result_s) *
|
||||
read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len)
|
||||
read_memory_robust (struct target_ops *ops,
|
||||
const ULONGEST offset, const LONGEST len)
|
||||
{
|
||||
VEC(memory_read_result_s) *result = 0;
|
||||
|
||||
LONGEST xfered = 0;
|
||||
while (xfered < len)
|
||||
LONGEST xfered_total = 0;
|
||||
while (xfered_total < len)
|
||||
{
|
||||
struct mem_region *region = lookup_mem_region (offset + xfered);
|
||||
LONGEST rlen;
|
||||
struct mem_region *region = lookup_mem_region (offset + xfered_total);
|
||||
LONGEST region_len;
|
||||
|
||||
/* If there is no explicit region, a fake one should be created. */
|
||||
gdb_assert (region);
|
||||
|
||||
if (region->hi == 0)
|
||||
rlen = len - xfered;
|
||||
region_len = len - xfered_total;
|
||||
else
|
||||
rlen = region->hi - offset;
|
||||
region_len = region->hi - offset;
|
||||
|
||||
if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
|
||||
{
|
||||
/* Cannot read this region. Note that we can end up here only
|
||||
if the region is explicitly marked inaccessible, or
|
||||
'inaccessible-by-default' is in effect. */
|
||||
xfered += rlen;
|
||||
xfered_total += region_len;
|
||||
}
|
||||
else
|
||||
{
|
||||
LONGEST to_read = min (len - xfered, rlen);
|
||||
LONGEST to_read = min (len - xfered_total, region_len);
|
||||
gdb_byte *buffer = (gdb_byte *)xmalloc (to_read);
|
||||
|
||||
LONGEST xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
|
||||
LONGEST xfered_partial =
|
||||
target_read (ops, TARGET_OBJECT_MEMORY, NULL,
|
||||
(gdb_byte *) buffer,
|
||||
offset + xfered, to_read);
|
||||
offset + xfered_total, to_read);
|
||||
/* Call an observer, notifying them of the xfer progress? */
|
||||
if (xfer <= 0)
|
||||
if (xfered_partial <= 0)
|
||||
{
|
||||
/* Got an error reading full chunk. See if maybe we can read
|
||||
some subrange. */
|
||||
xfree (buffer);
|
||||
read_whatever_is_readable (ops, offset + xfered,
|
||||
offset + xfered + to_read, &result);
|
||||
xfered += to_read;
|
||||
read_whatever_is_readable (ops, offset + xfered_total,
|
||||
offset + xfered_total + to_read, &result);
|
||||
xfered_total += to_read;
|
||||
}
|
||||
else
|
||||
{
|
||||
struct memory_read_result r;
|
||||
r.data = buffer;
|
||||
r.begin = offset + xfered;
|
||||
r.end = r.begin + xfer;
|
||||
r.begin = offset + xfered_total;
|
||||
r.end = r.begin + xfered_partial;
|
||||
VEC_safe_push (memory_read_result_s, result, &r);
|
||||
xfered += xfer;
|
||||
xfered_total += xfered_partial;
|
||||
}
|
||||
QUIT;
|
||||
}
|
||||
|
@ -1837,29 +1839,29 @@ target_write_with_progress (struct target_ops *ops,
|
|||
ULONGEST offset, LONGEST len,
|
||||
void (*progress) (ULONGEST, void *), void *baton)
|
||||
{
|
||||
LONGEST xfered = 0;
|
||||
LONGEST xfered_total = 0;
|
||||
|
||||
/* Give the progress callback a chance to set up. */
|
||||
if (progress)
|
||||
(*progress) (0, baton);
|
||||
|
||||
while (xfered < len)
|
||||
while (xfered_total < len)
|
||||
{
|
||||
ULONGEST xfered_len;
|
||||
ULONGEST xfered_partial;
|
||||
enum target_xfer_status status;
|
||||
|
||||
status = target_write_partial (ops, object, annex,
|
||||
(gdb_byte *) buf + xfered,
|
||||
offset + xfered, len - xfered,
|
||||
&xfered_len);
|
||||
(gdb_byte *) buf + xfered_total,
|
||||
offset + xfered_total, len - xfered_total,
|
||||
&xfered_partial);
|
||||
|
||||
if (status != TARGET_XFER_OK)
|
||||
return status == TARGET_XFER_EOF ? xfered : -1;
|
||||
return status == TARGET_XFER_EOF ? xfered_total : TARGET_XFER_E_IO;
|
||||
|
||||
if (progress)
|
||||
(*progress) (xfered_len, baton);
|
||||
(*progress) (xfered_partial, baton);
|
||||
|
||||
xfered += xfered_len;
|
||||
xfered_total += xfered_partial;
|
||||
QUIT;
|
||||
}
|
||||
return len;
|
||||
|
|
|
@ -297,8 +297,8 @@ DEF_VEC_O(memory_read_result_s);
|
|||
extern void free_memory_read_result_vector (void *);
|
||||
|
||||
extern VEC(memory_read_result_s)* read_memory_robust (struct target_ops *ops,
|
||||
ULONGEST offset,
|
||||
LONGEST len);
|
||||
const ULONGEST offset,
|
||||
const LONGEST len);
|
||||
|
||||
extern LONGEST target_write (struct target_ops *ops,
|
||||
enum target_object object,
|
||||
|
|
Loading…
Reference in a new issue