public inbox for gdb-patches@sourceware.org
 help / color / mirror / Atom feed
From: Simon Marchi <simon.marchi@ericsson.com>
To: <gdb-patches@sourceware.org>
Cc: Simon Marchi <simon.marchi@ericsson.com>
Subject: [PATCH v2 1/7] Various cleanups in target read/write code
Date: Wed, 15 Apr 2015 19:47:00 -0000	[thread overview]
Message-ID: <1429127258-1033-2-git-send-email-simon.marchi@ericsson.com> (raw)
In-Reply-To: <1429127258-1033-1-git-send-email-simon.marchi@ericsson.com>

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.
---
 gdb/target.c | 90 +++++++++++++++++++++++++++++++-----------------------------
 gdb/target.h |  6 ++--
 2 files changed, 49 insertions(+), 47 deletions(-)

diff --git a/gdb/target.c b/gdb/target.c
index 306c21d..fcf7090 100644
--- a/gdb/target.c
+++ b/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);
@@ -1669,7 +1669,7 @@ read_whatever_is_readable (struct target_ops *ops,
       ++current_begin;
     }
   else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
-				buf + (end-begin) - 1, end - 1, 1,
+				buf + (end - begin) - 1, end - 1, 1,
 				&xfered_len) == TARGET_XFER_OK)
     {
       forward = 0;
@@ -1691,7 +1691,7 @@ read_whatever_is_readable (struct target_ops *ops,
       ULONGEST first_half_begin, first_half_end;
       ULONGEST second_half_begin, second_half_end;
       LONGEST xfer;
-      ULONGEST middle = current_begin + (current_end - current_begin)/2;
+      ULONGEST middle = current_begin + (current_end - current_begin) / 2;
 
       if (forward)
 	{
@@ -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,
-				      (gdb_byte *) buffer,
-				      offset + xfered, to_read);
+	  LONGEST xfered_partial =
+	      target_read (ops, TARGET_OBJECT_MEMORY, NULL,
+			   (gdb_byte *) buffer,
+			   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;
diff --git a/gdb/target.h b/gdb/target.h
index f57e431..ad50f07 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -291,9 +291,9 @@ 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,
 			     const char *annex, const gdb_byte *buf,
-- 
2.1.4

  parent reply	other threads:[~2015-04-15 19:47 UTC|newest]

Thread overview: 34+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2015-04-15 19:47 [PATCH v2 0/7] Support reading/writing memory on architectures with non 8-bits addressable memory Simon Marchi
2015-04-15 19:47 ` [PATCH v2 5/7] target: consider addressable unit size when reading/writing memory Simon Marchi
2015-05-21 17:46   ` Pedro Alves
2015-06-12 21:07     ` Simon Marchi
2015-04-15 19:47 ` Simon Marchi [this message]
2015-05-21 17:45   ` [PATCH v2 1/7] Various cleanups in target read/write code Pedro Alves
2015-06-12 17:09     ` Simon Marchi
2015-04-15 19:47 ` [PATCH v2 3/7] Clarify doc about memory read/write and non-8-bits addressable memory unit sizes Simon Marchi
2015-04-16 14:48   ` Eli Zaretskii
2015-06-12 20:28     ` Simon Marchi
2015-06-13  6:49       ` Eli Zaretskii
2015-06-15 17:40         ` Simon Marchi
2015-06-15 18:09           ` Eli Zaretskii
2015-06-15 19:38             ` Simon Marchi
2015-04-15 19:48 ` [PATCH v2 6/7] remote: consider addressable unit size when reading/writing memory Simon Marchi
2015-05-21 17:48   ` Pedro Alves
2015-06-15 19:28     ` Simon Marchi
2015-06-17 11:55       ` Pedro Alves
2015-06-18 17:14         ` Simon Marchi
2015-04-15 19:48 ` [PATCH v2 7/7] MI: " Simon Marchi
2015-05-21 17:52   ` Pedro Alves
2015-06-15 19:51     ` Simon Marchi
2015-04-15 19:48 ` [PATCH v2 4/7] gdbarch: add addressable_memory_unit_size method Simon Marchi
2015-05-21 17:46   ` Pedro Alves
2015-06-12 20:54     ` Simon Marchi
2015-04-15 19:48 ` [PATCH v2 2/7] Cleanup some docs about memory write Simon Marchi
2015-05-21 17:45   ` Pedro Alves
2015-06-12 19:17     ` Simon Marchi
2015-06-15  9:57       ` Pedro Alves
2015-06-15 17:36         ` Simon Marchi
2015-05-21 17:44 ` [PATCH v2 0/7] Support reading/writing memory on architectures with non 8-bits addressable memory Pedro Alves
2015-06-11 21:06   ` Simon Marchi
2015-06-11 21:10     ` Simon Marchi
2015-06-12 12:00     ` Pedro Alves

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=1429127258-1033-2-git-send-email-simon.marchi@ericsson.com \
    --to=simon.marchi@ericsson.com \
    --cc=gdb-patches@sourceware.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).