* completer.c (location_completer): Fix typo in comment.

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

diff --git a/gdb/findcmd.c b/gdb/findcmd.c
index ad8edc8a896d278154d3e2d50cb9d4eb0d1d257e..1f970c0eb53727e7253d5af088e8a3201bc5ef9c 100644 (file)
--- a/gdb/findcmd.c
+++ b/gdb/findcmd.c
@@ -1,6 +1,6 @@
 /* The find command.
 
-   Copyright (C) 2008 Free Software Foundation, Inc.
+   Copyright (C) 2008-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -18,12 +18,12 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
+#include "arch-utils.h"
 #include <ctype.h>
 #include "gdb_string.h"
 #include "gdbcmd.h"
 #include "value.h"
 #include "target.h"
-#include "gdb_stdint.h"
 
 /* Copied from bfd_put_bits.  */
 
@@ -51,7 +51,8 @@ put_bits (bfd_uint64_t data, char *buf, int bits, bfd_boolean big_p)
 static void
 parse_find_args (char *args, ULONGEST *max_countp,
                 char **pattern_bufp, ULONGEST *pattern_lenp,
-                CORE_ADDR *start_addrp, ULONGEST *search_space_lenp)
+                CORE_ADDR *start_addrp, ULONGEST *search_space_lenp,
+                bfd_boolean big_p)
 {
   /* Default to using the specified type.  */
   char size = '\0';
@@ -68,7 +69,6 @@ parse_find_args (char *args, ULONGEST *max_countp,
   CORE_ADDR start_addr;
   ULONGEST search_space_len;
   char *s = args;
-  bfd_boolean big_p = gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG;
   struct cleanup *old_cleanups;
   struct value *v;
 
@@ -126,11 +126,13 @@ parse_find_args (char *args, ULONGEST *max_countp,
   if (*s == '+')
     {
       LONGEST len;
+
       ++s;
       v = parse_to_comma_and_eval (&s);
       len = value_as_long (v);
       if (len == 0)
        {
+         do_cleanups (old_cleanups);
          printf_filtered (_("Empty search range.\n"));
          return;
        }
@@ -145,16 +147,18 @@ parse_find_args (char *args, ULONGEST *max_countp,
   else
     {
       CORE_ADDR end_addr;
+
       v = parse_to_comma_and_eval (&s);
       end_addr = value_as_address (v);
       if (start_addr > end_addr)
-       error (_("Invalid search space, end preceeds start."));
+       error (_("Invalid search space, end precedes start."));
       search_space_len = end_addr - start_addr + 1;
       /* We don't support searching all of memory
         (i.e. start=0, end = 0xff..ff).
         Bail to avoid overflows later on.  */
       if (search_space_len == 0)
-       error (_("Overflow in address range computation, choose smaller range."));
+       error (_("Overflow in address range "
+                "computation, choose smaller range."));
     }
 
   if (*s == ',')
@@ -165,21 +169,24 @@ parse_find_args (char *args, ULONGEST *max_countp,
   while (*s != '\0')
     {
       LONGEST x;
-      int val_bytes;
+      struct type *t;
+      ULONGEST pattern_buf_size_need;
 
       while (isspace (*s))
        ++s;
 
       v = parse_to_comma_and_eval (&s);
-      val_bytes = TYPE_LENGTH (value_type (v));
+      t = value_type (v);
 
       /* Keep it simple and assume size == 'g' when watching for when we
         need to grow the pattern buf.  */
-      if ((pattern_buf_end - pattern_buf + max (val_bytes, sizeof (int64_t)))
-         > pattern_buf_size)
+      pattern_buf_size_need = (pattern_buf_end - pattern_buf
+                              + max (TYPE_LENGTH (t), sizeof (int64_t)));
+      if (pattern_buf_size_need > pattern_buf_size)
        {
          size_t current_offset = pattern_buf_end - pattern_buf;
-         pattern_buf_size *= 2;
+
+         pattern_buf_size = pattern_buf_size_need * 2;
          pattern_buf = xrealloc (pattern_buf, pattern_buf_size);
          pattern_buf_end = pattern_buf + current_offset;
        }
@@ -208,8 +215,8 @@ parse_find_args (char *args, ULONGEST *max_countp,
        }
       else
        {
-         memcpy (pattern_buf_end, value_contents_raw (v), val_bytes);
-         pattern_buf_end += val_bytes;
+         memcpy (pattern_buf_end, value_contents (v), TYPE_LENGTH (t));
+         pattern_buf_end += TYPE_LENGTH (t);
        }
 
       if (*s == ',')
@@ -240,6 +247,8 @@ parse_find_args (char *args, ULONGEST *max_countp,
 static void
 find_command (char *args, int from_tty)
 {
+  struct gdbarch *gdbarch = get_current_arch ();
+  bfd_boolean big_p = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG;
   /* Command line parameters.
      These are initialized to avoid uninitialized warnings from -Wall.  */
   ULONGEST max_count = 0;
@@ -253,7 +262,7 @@ find_command (char *args, int from_tty)
   struct cleanup *old_cleanups;
 
   parse_find_args (args, &max_count, &pattern_buf, &pattern_len, 
-                  &start_addr, &search_space_len);
+                  &start_addr, &search_space_len, big_p);
 
   old_cleanups = make_cleanup (free_current_contents, &pattern_buf);
 
@@ -274,7 +283,7 @@ find_command (char *args, int from_tty)
       if (found <= 0)
        break;
 
-      print_address (found_addr, gdb_stdout);
+      print_address (gdbarch, found_addr, gdb_stdout);
       printf_filtered ("\n");
       ++found_count;
       last_found_addr = found_addr;
@@ -292,14 +301,13 @@ find_command (char *args, int from_tty)
 
   /* Record and print the results.  */
 
-  set_internalvar (lookup_internalvar ("numfound"),
-                  value_from_longest (builtin_type_int,
-                                      (LONGEST) found_count));
+  set_internalvar_integer (lookup_internalvar ("numfound"), found_count);
   if (found_count > 0)
     {
+      struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
+
       set_internalvar (lookup_internalvar ("_"),
-                      value_from_pointer (builtin_type_void_data_ptr,
-                                          last_found_addr));
+                      value_from_pointer (ptr_type, last_found_addr));
     }
 
   if (found_count == 0)
@@ -311,13 +319,16 @@ find_command (char *args, int from_tty)
   do_cleanups (old_cleanups);
 }
 
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern initialize_file_ftype _initialize_mem_search;
+
 void
 _initialize_mem_search (void)
 {
   add_cmd ("find", class_vars, find_command, _("\
 Search memory for a sequence of bytes.\n\
-Usage:\n\
-find [/size-char] [/max-count] start-address, end-address, expr1 [, expr2 ...]\n\
+Usage:\nfind \
+[/size-char] [/max-count] start-address, end-address, expr1 [, expr2 ...]\n\
 find [/size-char] [/max-count] start-address, +length, expr1 [, expr2 ...]\n\
 size-char is one of b,h,w,g for 8,16,32,64 bit values respectively,\n\
 and if not specified the size is taken from the type of the expression\n\