Remove duplicate comment

[deliverable/binutils-gdb.git] / gdb / valprint.c

diff --git a/gdb/valprint.c b/gdb/valprint.c
index a87d67cc785d2250b4f922ca6941fbdd5a050652..b99530414b71e502e572c726bef2eb9174b633db 100644 (file)
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -29,7 +29,6 @@
 #include "valprint.h"
 #include "floatformat.h"
 #include "doublest.h"
-#include "exceptions.h"
 #include "dfp.h"
 #include "extension.h"
 #include "ada-lang.h"
@@ -308,8 +307,9 @@ valprint_check_validity (struct ui_file *stream,
       && TYPE_CODE (type) != TYPE_CODE_STRUCT
       && TYPE_CODE (type) != TYPE_CODE_ARRAY)
     {
-      if (!value_bits_valid (val, TARGET_CHAR_BIT * embedded_offset,
-                            TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+      if (value_bits_any_optimized_out (val,
+                                       TARGET_CHAR_BIT * embedded_offset,
+                                       TARGET_CHAR_BIT * TYPE_LENGTH (type)))
        {
          val_print_optimized_out (val, stream);
          return 0;
@@ -980,8 +980,9 @@ val_print_scalar_formatted (struct type *type,
 
   /* A scalar object that does not have all bits available can't be
      printed, because all bits contribute to its representation.  */
-  if (!value_bits_valid (val, TARGET_CHAR_BIT * embedded_offset,
-                             TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+  if (value_bits_any_optimized_out (val,
+                                   TARGET_CHAR_BIT * embedded_offset,
+                                   TARGET_CHAR_BIT * TYPE_LENGTH (type)))
     val_print_optimized_out (val, stream);
   else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
     val_print_unavailable (stream);
@@ -1682,12 +1683,12 @@ val_print_array_elements (struct type *type,
       if (options->repeat_count_threshold < UINT_MAX)
        {
          while (rep1 < len
-                && value_available_contents_eq (val,
-                                                embedded_offset + i * eltlen,
-                                                val,
-                                                (embedded_offset
-                                                 + rep1 * eltlen),
-                                                eltlen))
+                && value_contents_eq (val,
+                                      embedded_offset + i * eltlen,
+                                      val,
+                                      (embedded_offset
+                                       + rep1 * eltlen),
+                                      eltlen))
            {
              ++reps;
              ++rep1;
@@ -1792,36 +1793,23 @@ int
 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
             enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
 {
-  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.  */
 
-  /* 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 NUL terminator to end the fetching, so we might as
-     well read in blocks that are large enough to be efficient, but not so
-     large as to be slow if fetchlimit happens to be large.  So we choose the
-     minimum of 8 and fetchlimit.  We used to use 200 instead of 8 but
-     200 is way too big for remote debugging over a serial line.  */
-
-  chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
-
   /* Loop until we either have all the characters, or we encounter
      some error, such as bumping into the end of the address space.  */
 
-  found_nul = 0;
   *buffer = NULL;
 
   old_chain = make_cleanup (free_current_contents, buffer);
 
   if (len > 0)
     {
+      /* We want fetchlimit chars, so we might as well read them all in
+        one operation.  */
       unsigned int fetchlen = min (len, fetchlimit);
 
       *buffer = (gdb_byte *) xmalloc (fetchlen * width);
@@ -1835,6 +1823,18 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
   else if (len == -1)
     {
       unsigned long bufsize = 0;
+      unsigned int chunksize;  /* Size of each fetch, in chars.  */
+      int found_nul;           /* Non-zero if we found the nul char.  */
+      gdb_byte *limit;         /* First location past end of fetch buffer.  */
+
+      found_nul = 0;
+      /* We are looking for a NUL terminator to end the fetching, so we
+        might as well read in blocks that are large enough to be efficient,
+        but not so large as to be slow if fetchlimit happens to be large.
+        So we choose the minimum of 8 and fetchlimit.  We used to use 200
+        instead of 8 but 200 is way too big for remote debugging over a
+         serial line.  */
+      chunksize = min (8, fetchlimit);
 
       do
        {