gdb/findcmd.c

   1 /* The find command.
   2
   3    Copyright (C) 2008-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include <ctype.h>
  23 #include "gdbcmd.h"
  24 #include "value.h"
  25 #include "target.h"
  26 #include "cli/cli-utils.h"
  27 #include <algorithm>
  28
  29 /* Copied from bfd_put_bits.  */
  30
  31 static void
  32 put_bits (bfd_uint64_t data, gdb_byte *buf, int bits, bfd_boolean big_p)
  33 {
  34   int i;
  35   int bytes;
  36
  37   gdb_assert (bits % 8 == 0);
  38
  39   bytes = bits / 8;
  40   for (i = 0; i < bytes; i++)
  41     {
  42       int index = big_p ? bytes - i - 1 : i;
  43
  44       buf[index] = data & 0xff;
  45       data >>= 8;
  46     }
  47 }
  48
  49 /* Subroutine of find_command to simplify it.
  50    Parse the arguments of the "find" command.  */
  51
  52 static void
  53 parse_find_args (char *args, ULONGEST *max_countp,
  54                  gdb_byte **pattern_bufp, ULONGEST *pattern_lenp,
  55                  CORE_ADDR *start_addrp, ULONGEST *search_space_lenp,
  56                  bfd_boolean big_p)
  57 {
  58   /* Default to using the specified type.  */
  59   char size = '\0';
  60   ULONGEST max_count = ~(ULONGEST) 0;
  61   /* Buffer to hold the search pattern.  */
  62   gdb_byte *pattern_buf;
  63   /* Current size of search pattern buffer.
  64      We realloc space as needed.  */
  65 #define INITIAL_PATTERN_BUF_SIZE 100
  66   ULONGEST pattern_buf_size = INITIAL_PATTERN_BUF_SIZE;
  67   /* Pointer to one past the last in-use part of pattern_buf.  */
  68   gdb_byte *pattern_buf_end;
  69   ULONGEST pattern_len;
  70   CORE_ADDR start_addr;
  71   ULONGEST search_space_len;
  72   const char *s = args;
  73   struct cleanup *old_cleanups;
  74   struct value *v;
  75
  76   if (args == NULL)
  77     error (_("Missing search parameters."));
  78
  79   pattern_buf = (gdb_byte *) xmalloc (pattern_buf_size);
  80   pattern_buf_end = pattern_buf;
  81   old_cleanups = make_cleanup (free_current_contents, &pattern_buf);
  82
  83   /* Get search granularity and/or max count if specified.
  84      They may be specified in either order, together or separately.  */
  85
  86   while (*s == '/')
  87     {
  88       ++s;
  89
  90       while (*s != '\0' && *s != '/' && !isspace (*s))
  91         {
  92           if (isdigit (*s))
  93             {
  94               max_count = atoi (s);
  95               while (isdigit (*s))
  96                 ++s;
  97               continue;
  98             }
  99
 100           switch (*s)
 101             {
 102             case 'b':
 103             case 'h':
 104             case 'w':
 105             case 'g':
 106               size = *s++;
 107               break;
 108             default:
 109               error (_("Invalid size granularity."));
 110             }
 111         }
 112
 113       s = skip_spaces_const (s);
 114     }
 115
 116   /* Get the search range.  */
 117
 118   v = parse_to_comma_and_eval (&s);
 119   start_addr = value_as_address (v);
 120
 121   if (*s == ',')
 122     ++s;
 123   s = skip_spaces_const (s);
 124
 125   if (*s == '+')
 126     {
 127       LONGEST len;
 128
 129       ++s;
 130       v = parse_to_comma_and_eval (&s);
 131       len = value_as_long (v);
 132       if (len == 0)
 133         {
 134           do_cleanups (old_cleanups);
 135           printf_filtered (_("Empty search range.\n"));
 136           return;
 137         }
 138       if (len < 0)
 139         error (_("Invalid length."));
 140       /* Watch for overflows.  */
 141       if (len > CORE_ADDR_MAX
 142           || (start_addr + len - 1) < start_addr)
 143         error (_("Search space too large."));
 144       search_space_len = len;
 145     }
 146   else
 147     {
 148       CORE_ADDR end_addr;
 149
 150       v = parse_to_comma_and_eval (&s);
 151       end_addr = value_as_address (v);
 152       if (start_addr > end_addr)
 153         error (_("Invalid search space, end precedes start."));
 154       search_space_len = end_addr - start_addr + 1;
 155       /* We don't support searching all of memory
 156          (i.e. start=0, end = 0xff..ff).
 157          Bail to avoid overflows later on.  */
 158       if (search_space_len == 0)
 159         error (_("Overflow in address range "
 160                  "computation, choose smaller range."));
 161     }
 162
 163   if (*s == ',')
 164     ++s;
 165
 166   /* Fetch the search string.  */
 167
 168   while (*s != '\0')
 169     {
 170       LONGEST x;
 171       struct type *t;
 172       ULONGEST pattern_buf_size_need;
 173
 174       s = skip_spaces_const (s);
 175
 176       v = parse_to_comma_and_eval (&s);
 177       t = value_type (v);
 178
 179       /* Keep it simple and assume size == 'g' when watching for when we
 180          need to grow the pattern buf.  */
 181       pattern_buf_size_need = (pattern_buf_end - pattern_buf
 182                                + std::max (TYPE_LENGTH (t),
 183                                            (unsigned) sizeof (int64_t)));
 184       if (pattern_buf_size_need > pattern_buf_size)
 185         {
 186           size_t current_offset = pattern_buf_end - pattern_buf;
 187
 188           pattern_buf_size = pattern_buf_size_need * 2;
 189           pattern_buf = (gdb_byte *) xrealloc (pattern_buf, pattern_buf_size);
 190           pattern_buf_end = pattern_buf + current_offset;
 191         }
 192
 193       if (size != '\0')
 194         {
 195           x = value_as_long (v);
 196           switch (size)
 197             {
 198             case 'b':
 199               *pattern_buf_end++ = x;
 200               break;
 201             case 'h':
 202               put_bits (x, pattern_buf_end, 16, big_p);
 203               pattern_buf_end += sizeof (int16_t);
 204               break;
 205             case 'w':
 206               put_bits (x, pattern_buf_end, 32, big_p);
 207               pattern_buf_end += sizeof (int32_t);
 208               break;
 209             case 'g':
 210               put_bits (x, pattern_buf_end, 64, big_p);
 211               pattern_buf_end += sizeof (int64_t);
 212               break;
 213             }
 214         }
 215       else
 216         {
 217           memcpy (pattern_buf_end, value_contents (v), TYPE_LENGTH (t));
 218           pattern_buf_end += TYPE_LENGTH (t);
 219         }
 220
 221       if (*s == ',')
 222         ++s;
 223       s = skip_spaces_const (s);
 224     }
 225
 226   if (pattern_buf_end == pattern_buf)
 227     error (_("Missing search pattern."));
 228
 229   pattern_len = pattern_buf_end - pattern_buf;
 230
 231   if (search_space_len < pattern_len)
 232     error (_("Search space too small to contain pattern."));
 233
 234   *max_countp = max_count;
 235   *pattern_bufp = pattern_buf;
 236   *pattern_lenp = pattern_len;
 237   *start_addrp = start_addr;
 238   *search_space_lenp = search_space_len;
 239
 240   /* We successfully parsed the arguments, leave the freeing of PATTERN_BUF
 241      to the caller now.  */
 242   discard_cleanups (old_cleanups);
 243 }
 244
 245 static void
 246 find_command (char *args, int from_tty)
 247 {
 248   struct gdbarch *gdbarch = get_current_arch ();
 249   bfd_boolean big_p = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG;
 250   /* Command line parameters.
 251      These are initialized to avoid uninitialized warnings from -Wall.  */
 252   ULONGEST max_count = 0;
 253   gdb_byte *pattern_buf = 0;
 254   ULONGEST pattern_len = 0;
 255   CORE_ADDR start_addr = 0;
 256   ULONGEST search_space_len = 0;
 257   /* End of command line parameters.  */
 258   unsigned int found_count;
 259   CORE_ADDR last_found_addr;
 260   struct cleanup *old_cleanups;
 261
 262   parse_find_args (args, &max_count, &pattern_buf, &pattern_len,
 263                    &start_addr, &search_space_len, big_p);
 264
 265   old_cleanups = make_cleanup (free_current_contents, &pattern_buf);
 266
 267   /* Perform the search.  */
 268
 269   found_count = 0;
 270   last_found_addr = 0;
 271
 272   while (search_space_len >= pattern_len
 273          && found_count < max_count)
 274     {
 275       /* Offset from start of this iteration to the next iteration.  */
 276       ULONGEST next_iter_incr;
 277       CORE_ADDR found_addr;
 278       int found = target_search_memory (start_addr, search_space_len,
 279                                         pattern_buf, pattern_len, &found_addr);
 280
 281       if (found <= 0)
 282         break;
 283
 284       print_address (gdbarch, found_addr, gdb_stdout);
 285       printf_filtered ("\n");
 286       ++found_count;
 287       last_found_addr = found_addr;
 288
 289       /* Begin next iteration at one byte past this match.  */
 290       next_iter_incr = (found_addr - start_addr) + 1;
 291
 292       /* For robustness, we don't let search_space_len go -ve here.  */
 293       if (search_space_len >= next_iter_incr)
 294         search_space_len -= next_iter_incr;
 295       else
 296         search_space_len = 0;
 297       start_addr += next_iter_incr;
 298     }
 299
 300   /* Record and print the results.  */
 301
 302   set_internalvar_integer (lookup_internalvar ("numfound"), found_count);
 303   if (found_count > 0)
 304     {
 305       struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 306
 307       set_internalvar (lookup_internalvar ("_"),
 308                        value_from_pointer (ptr_type, last_found_addr));
 309     }
 310
 311   if (found_count == 0)
 312     printf_filtered ("Pattern not found.\n");
 313   else
 314     printf_filtered ("%d pattern%s found.\n", found_count,
 315                      found_count > 1 ? "s" : "");
 316
 317   do_cleanups (old_cleanups);
 318 }
 319
 320 void
 321 _initialize_mem_search (void)
 322 {
 323   add_cmd ("find", class_vars, find_command, _("\
 324 Search memory for a sequence of bytes.\n\
 325 Usage:\nfind \
 326 [/size-char] [/max-count] start-address, end-address, expr1 [, expr2 ...]\n\
 327 find [/size-char] [/max-count] start-address, +length, expr1 [, expr2 ...]\n\
 328 size-char is one of b,h,w,g for 8,16,32,64 bit values respectively,\n\
 329 and if not specified the size is taken from the type of the expression\n\
 330 in the current language.\n\
 331 Note that this means for example that in the case of C-like languages\n\
 332 a search for an untyped 0x42 will search for \"(int) 0x42\"\n\
 333 which is typically four bytes.\n\
 334 \n\
 335 The address of the last match is stored as the value of \"$_\".\n\
 336 Convenience variable \"$numfound\" is set to the number of matches."),
 337            &cmdlist);
 338 }