Mirror of the gdb-patches mailing list
 help / color / mirror / Atom feed
* [RFA] Add la_getstr member to language_defn
@ 2008-11-24 13:24 Thiago Jung Bauermann
  2008-11-24 13:32 ` Daniel Jacobowitz
  2008-11-24 20:03 ` Tom Tromey
  0 siblings, 2 replies; 33+ messages in thread
From: Thiago Jung Bauermann @ 2008-11-24 13:24 UTC (permalink / raw)
  To: gdb-patches ml

Hi,

In the python branch, I needed to read a string fro the inferior in a
language-agnostic way. There's currently no way to do that. This patch
addresses the issue by providing a la_getstr function to language_defn.
Each language supported by GDB can provide a way to read strings from a
value by suppling its version of the function. I implemented it for C,
in c_getstr. It assumes NULL-terminated strings, but doesn't assume that
characters are 1-byte wide. I installed c_getstr for C++ and asm as
well.

I also factored out a read_string function out of val_print_string,
which is handy to use as a base for la_getstr implementations.

I intend to post a patch which extends the value binding in python to
use this code Real Soon Nowâ„¢.

One improvement which is easy to make but I left for later (this patch
is big enough already) is to nuke target_read_string and make its
callers use read_string instead (the former implements just a subset of
what the latter provides). It would be a simple modification, but would
affect code specific to targets to which I don't have access to
(target_read_string is almost exclusively used in solib-*.c). I can work
on a subsequent patch to do that if you think it's safe enough to not
require my testing on all affected targets.

Tested on ppc-linux, introduces no regression. Ok to commit?
-- 
[]'s
Thiago Jung Bauermann
IBM Linux Technology Center


2008-11-23  Thiago Jung Bauermann  <bauerman@br.ibm.com>

	* language.h (language_dfn): Add la_getstr member.
	(LA_GET_STRING): New macro.
	(default_getstr): New prototype.
	* language.c (default_getstr): New function.
	(unknown_language_defn, auto_language_defn, local_language_defn): Use
	default_getstr for la_getstr.
	* c-lang.c (c_getstr): New function.
	(c_language_defn, cplus_language_defn, asm_language_defn): Use
	c_getstr for la_getstr.
	(minimal_language_defn): Use default_getstr for la_getstr.
	* ada-lang.c (ada_language_defn): Likewise.
	* f-lang.c (f_language_defn): Likewise.
	* jv-lang.c (java_language_defn): Likewise.
	* m2-lang.c (m2_language_defn): Likewise.
	* objc-lang.c (objc_language_defn): Likewise.
	* p-lang.c (p_language_defn): Likewise.
	* scm-lang.c (scm_language_defn): Likewise.
	* typeprint.c (type_to_string): New function.
	* value.h (type_to_string): New prototype.
	* valprint.c (val_print_string): Factor out code for reading string
	from the inferior into its own function.  Put 2 spaces after period
	in comments.
	(read_string): New function.
	* valprint.h (read_string): New prototype.

Index: gdb.git/gdb/ada-lang.c
===================================================================
--- gdb.git.orig/gdb/ada-lang.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/ada-lang.c	2008-11-23 02:55:37.000000000 -0200
@@ -11084,6 +11084,7 @@ const struct language_defn ada_language_
   ada_language_arch_info,
   ada_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
Index: gdb.git/gdb/c-lang.c
===================================================================
--- gdb.git.orig/gdb/c-lang.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/c-lang.c	2008-11-23 02:55:44.000000000 -0200
@@ -181,6 +181,104 @@ c_printstr (struct ui_file *stream, cons
   if (force_ellipses || i < length)
     fputs_filtered ("...", stream);
 }
+
+/* Obtain a C string from the inferior, storing it in a newly allocated
+   buffer in BUFFER, which should be freed by the caller.  If VALUE is an
+   array with known length, the function will copy all of its contents to
+   the buffer.  If the length is not known, read until a null byte is found.
+   LENGTH will contain the size of the string (not counting the NULL
+   character).
+
+   Assumes strings are terminated by a NULL character.  The size of a character
+   is determined by the length of the target type of the pointer or array.
+   This means that a NULL byte present in a multi-byte character will not
+   terminate the string unless the whole character is NULL.
+
+   Unless an exception is thrown, BUFFER will always be allocated, even on
+   failure.  In this case, some characters might have been read before the
+   failure happened.  Check LENGTH to recognize this situation.
+
+   Return 0 on success, errno on failure.  */
+
+static int
+c_getstr (struct value *value, gdb_byte **buffer, int *length)
+{
+  int fetchlimit, err, width;
+  struct type *type = value_type (value);
+  struct type *element_type = TYPE_TARGET_TYPE (type);
+
+  if (element_type == NULL)
+    goto error;
+
+  if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+    {
+      /* If we know the size of the array, we can use it as a limit on the
+	 number of characters to be fetched.  */
+      if ((TYPE_NFIELDS (type) == 1)
+	  && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
+	{
+	  LONGEST low_bound, high_bound;
+
+	  get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
+			       &low_bound, &high_bound);
+	  fetchlimit = high_bound - low_bound + 1;
+	}
+      else
+	fetchlimit = -1;
+    }
+  else if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR)
+    fetchlimit = -1;
+  else
+    /* We work only with arrays and pointers.  */
+    goto error;
+
+  element_type = check_typedef (element_type);
+  if ((TYPE_CODE (element_type) != TYPE_CODE_INT)
+      && (TYPE_CODE (element_type) != TYPE_CODE_CHAR))
+    /* If the elements are not integers or characters, we don't consider it
+       a string.  */
+    goto error;
+
+  width = TYPE_LENGTH (element_type);
+
+  /* If the string lives in GDB's memory intead of the inferior's, then we
+     just need to copy it to BUFFER.  Also, since such strings are arrays
+     with known size, FETCHLIMIT will hold the size of the string.  */
+  if (((VALUE_LVAL (value) == not_lval)
+      || (VALUE_LVAL (value) == lval_internalvar)) && (fetchlimit != -1))
+    {
+      *length = fetchlimit;
+      *buffer = xmalloc (*length * width);
+      memcpy (*buffer, value_contents (value), *length * width);
+      err = 0;
+    }
+  else
+    err = read_string (value_as_address (value), -1, width, fetchlimit,
+			 buffer, length);
+
+  /* If the last character is NULL, subtract it from length.  */
+  if (extract_unsigned_integer (*buffer + *length - width, width) == 0)
+      *length -= width;
+
+  return err;
+
+error:
+  {
+    char *type_str;
+    struct cleanup *old_chain;
+
+    type_str = type_to_string (type);
+    if (type_str)
+      {
+	old_chain = make_cleanup (xfree, type_str);
+	error (_("Trying to read string with inappropriate type `%s'."),
+	       type_str);
+      }
+    else
+      error (_("Trying to read string with inappropriate type."));
+  }
+}
+
 \f
 /* Preprocessing and parsing C and C++ expressions.  */
 
@@ -419,6 +517,7 @@ const struct language_defn c_language_de
   c_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
+  c_getstr,
   LANG_MAGIC
 };
 
@@ -537,6 +636,7 @@ const struct language_defn cplus_languag
   cplus_language_arch_info,
   default_print_array_index,
   cp_pass_by_reference,
+  c_getstr,
   LANG_MAGIC
 };
 
@@ -574,6 +674,7 @@ const struct language_defn asm_language_
   c_language_arch_info, /* FIXME: la_language_arch_info.  */
   default_print_array_index,
   default_pass_by_reference,
+  c_getstr,
   LANG_MAGIC
 };
 
@@ -616,6 +717,7 @@ const struct language_defn minimal_langu
   c_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
Index: gdb.git/gdb/f-lang.c
===================================================================
--- gdb.git.orig/gdb/f-lang.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/f-lang.c	2008-11-23 02:55:37.000000000 -0200
@@ -343,6 +343,7 @@ const struct language_defn f_language_de
   f_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
Index: gdb.git/gdb/jv-lang.c
===================================================================
--- gdb.git.orig/gdb/jv-lang.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/jv-lang.c	2008-11-23 02:55:37.000000000 -0200
@@ -1128,6 +1128,7 @@ const struct language_defn java_language
   java_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
Index: gdb.git/gdb/language.c
===================================================================
--- gdb.git.orig/gdb/language.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/language.c	2008-11-23 02:55:37.000000000 -0200
@@ -1043,6 +1043,12 @@ default_print_array_index (struct value 
   fprintf_filtered (stream, "] = ");
 }
 
+int
+default_getstr (struct value *value, gdb_byte **buffer, int *length)
+{
+  error (_("Getting a string is unsupported in this language."));
+}
+
 /* Define the language that is no language.  */
 
 static int
@@ -1165,6 +1171,7 @@ const struct language_defn unknown_langu
   unknown_language_arch_info,	/* la_language_arch_info.  */
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
@@ -1203,6 +1210,7 @@ const struct language_defn auto_language
   unknown_language_arch_info,	/* la_language_arch_info.  */
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
@@ -1240,6 +1248,7 @@ const struct language_defn local_languag
   unknown_language_arch_info,	/* la_language_arch_info.  */
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 \f
Index: gdb.git/gdb/language.h
===================================================================
--- gdb.git.orig/gdb/language.h	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/language.h	2008-11-23 02:55:37.000000000 -0200
@@ -282,6 +282,12 @@ struct language_defn
        reference at the language level.  */
     int (*la_pass_by_reference) (struct type *type);
 
+    /* Obtain a string from the inferior, storing it in a newly allocated
+       buffer in BUFFER, which should be freed by the caller.  LENGTH will
+       hold the size in bytes of the string (only actual characters, excluding
+       an eventual NULL terminating character).  */
+    int (*la_getstr) (struct value *value, gdb_byte **buffer, int *length);
+
     /* Add fields above this point, so the magic number is always last. */
     /* Magic number for compat checking */
 
@@ -380,6 +386,8 @@ extern enum language set_language (enum 
 				 force_ellipses,options))
 #define LA_EMIT_CHAR(ch, stream, quoter) \
   (current_language->la_emitchar(ch, stream, quoter))
+#define LA_GET_STRING(value, buffer, length) \
+  (current_language->la_getstr(value, buffer, length))
 
 #define LA_PRINT_ARRAY_INDEX(index_value, stream, optins) \
   (current_language->la_print_array_index(index_value, stream, options))
@@ -489,4 +497,6 @@ int default_pass_by_reference (struct ty
 void default_print_typedef (struct type *type, struct symbol *new_symbol,
 			    struct ui_file *stream);
 
+int default_getstr (struct value *value, gdb_byte **buffer, int *length);
+
 #endif /* defined (LANGUAGE_H) */
Index: gdb.git/gdb/m2-lang.c
===================================================================
--- gdb.git.orig/gdb/m2-lang.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/m2-lang.c	2008-11-23 02:55:37.000000000 -0200
@@ -394,6 +394,7 @@ const struct language_defn m2_language_d
   m2_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
Index: gdb.git/gdb/objc-lang.c
===================================================================
--- gdb.git.orig/gdb/objc-lang.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/objc-lang.c	2008-11-23 02:55:37.000000000 -0200
@@ -531,6 +531,7 @@ const struct language_defn objc_language
   c_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
Index: gdb.git/gdb/p-lang.c
===================================================================
--- gdb.git.orig/gdb/p-lang.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/p-lang.c	2008-11-23 02:55:37.000000000 -0200
@@ -433,6 +433,7 @@ const struct language_defn pascal_langua
   pascal_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
Index: gdb.git/gdb/scm-lang.c
===================================================================
--- gdb.git.orig/gdb/scm-lang.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/scm-lang.c	2008-11-23 02:55:37.000000000 -0200
@@ -273,6 +273,7 @@ const struct language_defn scm_language_
   c_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
+  default_getstr,
   LANG_MAGIC
 };
 
Index: gdb.git/gdb/typeprint.c
===================================================================
--- gdb.git.orig/gdb/typeprint.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/typeprint.c	2008-11-23 02:55:37.000000000 -0200
@@ -33,6 +33,7 @@
 #include "cp-abi.h"
 #include "typeprint.h"
 #include "gdb_string.h"
+#include "exceptions.h"
 #include "valprint.h"
 #include <errno.h>
 
@@ -78,6 +79,34 @@ type_print (struct type *type, char *var
   LA_PRINT_TYPE (type, varstring, stream, show, 0);
 }
 
+/* Print TYPE to a string, returning it.  The caller is responsible for
+   freeing the string.  */
+
+char *
+type_to_string (struct type *type)
+{
+  char *s = NULL;
+  long dummy;
+  struct ui_file *stb;
+  struct cleanup *old_chain;
+  volatile struct gdb_exception except;
+
+  stb = mem_fileopen ();
+  old_chain = make_cleanup_ui_file_delete (stb);
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      type_print (type, "", stb, -1);
+      s = ui_file_xstrdup (stb, &dummy);
+    }
+  if (except.reason < 0)
+    s = NULL;
+
+  do_cleanups (old_chain);
+
+  return s;
+}
+
 /* Print type of EXP, or last thing in value history if EXP == NULL.
    show is passed to type_print.  */
 
Index: gdb.git/gdb/valprint.c
===================================================================
--- gdb.git.orig/gdb/valprint.c	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/valprint.c	2008-11-23 02:55:37.000000000 -0200
@@ -1177,40 +1177,40 @@ partial_memory_read (CORE_ADDR memaddr, 
   return (nread);
 }
 
-/*  Print a string from the inferior, starting at ADDR and printing up to LEN
-   characters, of WIDTH bytes a piece, to STREAM.  If LEN is -1, printing
-   stops at the first null byte, otherwise printing proceeds (including null
-   bytes) until either print_max or LEN characters have been printed,
-   whichever is smaller. */
-
-/* FIXME: Use target_read_string.  */
+/* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
+   each.  Fetch at most FETCHLIMIT characters.  BUFFER will be set to a newly
+   allocated buffer containing the string, which the caller is responsible to
+   free, and BYTES_READ will be set to the number of bytes read.  Returns 0 on
+   success, or errno on failure.
+
+   If LEN is -1, stops at the first null character (not necessarily the first
+   null byte), otherwise reading proceeds (including null characters) until
+   FETCHLIMIT characters have been read.  Set FETCHLIMIT to UINT_MAX to read
+   as many characters as possible from the string.
+
+   Unless an exception is thrown, BUFFER will always be allocated, even on
+   failure.  In this case, some characters might have been read before the
+   failure happened.  Check BYTES_READ to recognize this situation.
+
+   Note: There was a FIXME asking to make this code use target_read_string,
+   but this function is more general (can read past null characters, up to
+   given LEN). Besides, it is used much more often than target_read_string
+   so it is more tested.  Perhaps target_read_string should be rewritten to
+   use this function?  */
 
 int
-val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream,
-		  const struct value_print_options *options)
+read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
+	     gdb_byte **buffer, int *bytes_read)
 {
-  int force_ellipsis = 0;	/* Force ellipsis to be printed if nonzero. */
-  int errcode;			/* Errno returned from bad reads. */
-  unsigned int fetchlimit;	/* Maximum number of chars to print. */
-  unsigned int nfetch;		/* Chars to fetch / chars fetched. */
-  unsigned int chunksize;	/* Size of each fetch, in chars. */
-  gdb_byte *buffer = NULL;	/* Dynamically growable fetch buffer. */
-  gdb_byte *bufptr;		/* Pointer to next available byte in buffer. */
-  gdb_byte *limit;		/* First location past end of fetch buffer. */
-  struct cleanup *old_chain = NULL;	/* Top of the old cleanup chain. */
-  int found_nul;		/* Non-zero if we found the nul char */
+  int found_nul;		/* Non-zero if we found the nul char.  */
+  int errcode;			/* Errno returned from bad reads.  */
+  unsigned int nfetch;		/* Chars to fetch / chars fetched.  */
+  unsigned int chunksize;	/* Size of each fetch, in chars.  */
+  gdb_byte *bufptr;		/* Pointer to next available byte in buffer.  */
+  gdb_byte *limit;		/* First location past end of fetch buffer.  */
+  struct cleanup *old_chain = NULL;	/* Top of the old cleanup chain.  */
 
-  /* First we need to figure out the limit on the number of characters we are
-     going to attempt to fetch and print.  This is actually pretty simple.  If
-     LEN >= zero, then the limit is the minimum of LEN and print_max.  If
-     LEN is -1, then the limit is print_max.  This is true regardless of
-     whether print_max is zero, UINT_MAX (unlimited), or something in between,
-     because finding the null byte (or available memory) is what actually
-     limits the fetch. */
-
-  fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max));
-
-  /* Now decide how large of chunks to try to read in one operation.  This
+  /* Decide how large of chunks to try to read in one operation.  This
      is also pretty simple.  If LEN >= zero, then we want fetchlimit chars,
      so we might as well read them all in one operation.  If LEN is -1, we
      are looking for a null terminator to end the fetching, so we might as
@@ -1222,16 +1222,16 @@ val_print_string (CORE_ADDR addr, int le
   chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
 
   /* Loop until we either have all the characters to print, or we encounter
-     some error, such as bumping into the end of the address space. */
+     some error, such as bumping into the end of the address space.  */
 
   found_nul = 0;
   old_chain = make_cleanup (null_cleanup, 0);
 
   if (len > 0)
     {
-      buffer = (gdb_byte *) xmalloc (len * width);
-      bufptr = buffer;
-      old_chain = make_cleanup (xfree, buffer);
+      *buffer = (gdb_byte *) xmalloc (len * width);
+      bufptr = *buffer;
+      old_chain = make_cleanup (xfree, *buffer);
 
       nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
 	/ width;
@@ -1241,32 +1241,36 @@ val_print_string (CORE_ADDR addr, int le
   else if (len == -1)
     {
       unsigned long bufsize = 0;
+
+      *buffer = NULL;
+
       do
 	{
 	  QUIT;
 	  nfetch = min (chunksize, fetchlimit - bufsize);
 
-	  if (buffer == NULL)
-	    buffer = (gdb_byte *) xmalloc (nfetch * width);
+	  if (*buffer == NULL)
+	    *buffer = (gdb_byte *) xmalloc (nfetch * width);
 	  else
 	    {
 	      discard_cleanups (old_chain);
-	      buffer = (gdb_byte *) xrealloc (buffer, (nfetch + bufsize) * width);
+	      *buffer = (gdb_byte *) xrealloc (*buffer,
+					       (nfetch + bufsize) * width);
 	    }
 
-	  old_chain = make_cleanup (xfree, buffer);
-	  bufptr = buffer + bufsize * width;
+	  old_chain = make_cleanup (xfree, *buffer);
+	  bufptr = *buffer + bufsize * width;
 	  bufsize += nfetch;
 
-	  /* Read as much as we can. */
+	  /* Read as much as we can.  */
 	  nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
-	    / width;
+		    / width;
 
 	  /* Scan this chunk for the null byte that terminates the string
 	     to print.  If found, we don't need to fetch any more.  Note
 	     that bufptr is explicitly left pointing at the next character
 	     after the null byte, or at the next character after the end of
-	     the buffer. */
+	     the buffer.  */
 
 	  limit = bufptr + nfetch * width;
 	  while (bufptr < limit)
@@ -1287,20 +1291,65 @@ val_print_string (CORE_ADDR addr, int le
 	    }
 	}
       while (errcode == 0	/* no error */
-	     && bufptr - buffer < fetchlimit * width	/* no overrun */
+	     && bufptr - *buffer < fetchlimit * width	/* no overrun */
 	     && !found_nul);	/* haven't found nul yet */
     }
   else
-    {				/* length of string is really 0! */
-      buffer = bufptr = NULL;
+    {				/* Length of string is really 0!  */
+      *buffer = bufptr = NULL;
       errcode = 0;
     }
 
   /* bufptr and addr now point immediately beyond the last byte which we
      consider part of the string (including a '\0' which ends the string).  */
+  *bytes_read = bufptr - *buffer;
+
+  QUIT;
+
+  discard_cleanups (old_chain);
+
+  return errcode;
+}
+
+/* Print a string from the inferior, starting at ADDR and printing up to LEN
+   characters, of WIDTH bytes a piece, to STREAM.  If LEN is -1, printing
+   stops at the first null byte, otherwise printing proceeds (including null
+   bytes) until either print_max or LEN characters have been printed,
+   whichever is smaller.  */
+
+int
+val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream,
+		  const struct value_print_options *options)
+{
+  int force_ellipsis = 0;	/* Force ellipsis to be printed if nonzero.  */
+  int errcode;			/* Errno returned from bad reads.  */
+  int found_nul;		/* Non-zero if we found the nul char */
+  unsigned int fetchlimit;	/* Maximum number of chars to print.  */
+  int bytes_read;
+  gdb_byte *buffer = NULL;	/* Dynamically growable fetch buffer.  */
+  CORE_ADDR addr_next;		/* Address right after the last read byte.  */
+  struct cleanup *old_chain = NULL;	/* Top of the old cleanup chain.  */
+
+  /* First we need to figure out the limit on the number of characters we are
+     going to attempt to fetch and print.  This is actually pretty simple.  If
+     LEN >= zero, then the limit is the minimum of LEN and print_max.  If
+     LEN is -1, then the limit is print_max.  This is true regardless of
+     whether print_max is zero, UINT_MAX (unlimited), or something in between,
+     because finding the null byte (or available memory) is what actually
+     limits the fetch.  */
+
+  fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max));
+
+  errcode = read_string (addr, len, width, fetchlimit, &buffer, &bytes_read);
+  old_chain = make_cleanup (xfree, buffer);
+
+  addr_next = addr + bytes_read;
 
   /* We now have either successfully filled the buffer to fetchlimit, or
-     terminated early due to an error or finding a null char when LEN is -1. */
+     terminated early due to an error or finding a null char when LEN is -1.  */
+
+  /* Determine found_nul by looking at the last character read.  */
+  found_nul = extract_unsigned_integer (buffer + bytes_read - width, width) == 0;
 
   if (len == -1 && !found_nul)
     {
@@ -1312,30 +1361,28 @@ val_print_string (CORE_ADDR addr, int le
 
       peekbuf = (gdb_byte *) alloca (width);
 
-      if (target_read_memory (addr, peekbuf, width) == 0
+      if (target_read_memory (addr_next, peekbuf, width) == 0
 	  && extract_unsigned_integer (peekbuf, width) != 0)
 	force_ellipsis = 1;
     }
-  else if ((len >= 0 && errcode != 0) || (len > (bufptr - buffer) / width))
+  else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
     {
       /* Getting an error when we have a requested length, or fetching less
          than the number of characters actually requested, always make us
-         print ellipsis. */
+         print ellipsis.  */
       force_ellipsis = 1;
     }
 
-  QUIT;
-
   /* If we get an error before fetching anything, don't print a string.
      But if we fetch something and then get an error, print the string
      and then the error message.  */
-  if (errcode == 0 || bufptr > buffer)
+  if (errcode == 0 || bytes_read > 0)
     {
       if (options->addressprint)
 	{
 	  fputs_filtered (" ", stream);
 	}
-      LA_PRINT_STRING (stream, buffer, (bufptr - buffer) / width, width, force_ellipsis, options);
+      LA_PRINT_STRING (stream, buffer, bytes_read / width, width, force_ellipsis, options);
     }
 
   if (errcode != 0)
@@ -1343,19 +1390,21 @@ val_print_string (CORE_ADDR addr, int le
       if (errcode == EIO)
 	{
 	  fprintf_filtered (stream, " <Address ");
-	  fputs_filtered (paddress (addr), stream);
+	  fputs_filtered (paddress (addr_next), stream);
 	  fprintf_filtered (stream, " out of bounds>");
 	}
       else
 	{
 	  fprintf_filtered (stream, " <Error reading address ");
-	  fputs_filtered (paddress (addr), stream);
+	  fputs_filtered (paddress (addr_next), stream);
 	  fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
 	}
     }
+
   gdb_flush (stream);
   do_cleanups (old_chain);
-  return ((bufptr - buffer) / width);
+
+  return (bytes_read / width);
 }
 \f
 
Index: gdb.git/gdb/valprint.h
===================================================================
--- gdb.git.orig/gdb/valprint.h	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/valprint.h	2008-11-23 02:55:37.000000000 -0200
@@ -136,4 +136,7 @@ extern void print_hex_chars (struct ui_f
 
 extern void print_char_chars (struct ui_file *, const gdb_byte *,
 			      unsigned int, enum bfd_endian);
+
+int read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
+		 gdb_byte **buffer, int *bytes_read);
 #endif
Index: gdb.git/gdb/value.h
===================================================================
--- gdb.git.orig/gdb/value.h	2008-11-23 02:33:57.000000000 -0200
+++ gdb.git/gdb/value.h	2008-11-23 02:55:37.000000000 -0200
@@ -514,6 +514,8 @@ extern void modify_field (gdb_byte *addr
 extern void type_print (struct type *type, char *varstring,
 			struct ui_file *stream, int show);
 
+extern char * type_to_string (struct type *type);
+
 extern gdb_byte *baseclass_addr (struct type *type, int index,
 				 gdb_byte *valaddr,
 				 struct value **valuep, int *errp);



^ permalink raw reply	[flat|nested] 33+ messages in thread
end of thread, other threads:[~2009-02-05 23:51 UTC | newest]

Thread overview: 33+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2008-11-24 13:24 [RFA] Add la_getstr member to language_defn Thiago Jung Bauermann
2008-11-24 13:32 ` Daniel Jacobowitz
2008-11-24 14:59   ` Thiago Jung Bauermann
2008-11-24 16:19     ` Daniel Jacobowitz
2008-11-24 20:22       ` Thiago Jung Bauermann
2008-11-25  2:16         ` Daniel Jacobowitz
2008-11-25  8:53           ` Thiago Jung Bauermann
2009-01-03  2:27             ` Thiago Jung Bauermann
2009-02-02 18:42               ` Tom Tromey
2009-02-03 12:51                 ` Thiago Jung Bauermann
2009-02-03 17:44                   ` Tom Tromey
2009-02-04 12:37                     ` Thiago Jung Bauermann
2009-02-04 19:19                       ` Tom Tromey
2009-02-04 22:26                         ` Thiago Jung Bauermann
2009-02-05  0:55                           ` Tom Tromey
2009-02-05 12:21                             ` Thiago Jung Bauermann
2009-02-05 16:01                               ` Pierre Muller
2009-02-05 16:30                                 ` Thiago Jung Bauermann
2009-02-05 16:46                                 ` Tom Tromey
2009-02-05 15:55                           ` Tom Tromey
2009-02-05 16:07                             ` Pierre Muller
2009-02-05 16:33                               ` Thiago Jung Bauermann
2009-02-05 16:46                                 ` Tom Tromey
2009-02-03  0:23               ` Joel Brobecker
2009-02-03 13:02                 ` Thiago Jung Bauermann
2009-02-03 17:01                   ` Joel Brobecker
2009-02-03 17:40                     ` Tom Tromey
2009-02-05 17:01                     ` Thiago Jung Bauermann
2009-02-05 23:51                       ` Joel Brobecker
2008-11-24 20:03 ` Tom Tromey
2008-11-24 21:19   ` Thiago Jung Bauermann
2008-11-25  0:55     ` Tom Tromey
2008-11-25 11:27       ` Thiago Jung Bauermann

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox