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

/* The find command.

   Copyright (C) 2008-2013 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   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 "cli/cli-utils.h"

/* Copied from bfd_put_bits.  */

static void
put_bits (bfd_uint64_t data, gdb_byte *buf, int bits, bfd_boolean big_p)
{
  int i;
  int bytes;

  gdb_assert (bits % 8 == 0);

  bytes = bits / 8;
  for (i = 0; i < bytes; i++)
    {
      int index = big_p ? bytes - i - 1 : i;

      buf[index] = data & 0xff;
      data >>= 8;
    }
}

/* Subroutine of find_command to simplify it.
   Parse the arguments of the "find" command.  */

static void
parse_find_args (char *args, ULONGEST *max_countp,
		 gdb_byte **pattern_bufp, ULONGEST *pattern_lenp,
		 CORE_ADDR *start_addrp, ULONGEST *search_space_lenp,
		 bfd_boolean big_p)
{
  /* Default to using the specified type.  */
  char size = '\0';
  ULONGEST max_count = ~(ULONGEST) 0;
  /* Buffer to hold the search pattern.  */
  gdb_byte *pattern_buf;
  /* Current size of search pattern buffer.
     We realloc space as needed.  */
#define INITIAL_PATTERN_BUF_SIZE 100
  ULONGEST pattern_buf_size = INITIAL_PATTERN_BUF_SIZE;
  /* Pointer to one past the last in-use part of pattern_buf.  */
  gdb_byte *pattern_buf_end;
  ULONGEST pattern_len;
  CORE_ADDR start_addr;
  ULONGEST search_space_len;
  char *s = args;
  struct cleanup *old_cleanups;
  struct value *v;

  if (args == NULL)
    error (_("Missing search parameters."));

  pattern_buf = xmalloc (pattern_buf_size);
  pattern_buf_end = pattern_buf;
  old_cleanups = make_cleanup (free_current_contents, &pattern_buf);

  /* Get search granularity and/or max count if specified.
     They may be specified in either order, together or separately.  */

  while (*s == '/')
    {
      ++s;

      while (*s != '\0' && *s != '/' && !isspace (*s))
	{
	  if (isdigit (*s))
	    {
	      max_count = atoi (s);
	      while (isdigit (*s))
		++s;
	      continue;
	    }

	  switch (*s)
	    {
	    case 'b':
	    case 'h':
	    case 'w':
	    case 'g':
	      size = *s++;
	      break;
	    default:
	      error (_("Invalid size granularity."));
	    }
	}

      s = skip_spaces (s);
    }

  /* Get the search range.  */

  v = parse_to_comma_and_eval (&s);
  start_addr = value_as_address (v);

  if (*s == ',')
    ++s;
  s = skip_spaces (s);

  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;
	}
      if (len < 0)
	error (_("Invalid length."));
      /* Watch for overflows.  */
      if (len > CORE_ADDR_MAX
	  || (start_addr + len - 1) < start_addr)
	error (_("Search space too large."));
      search_space_len = len;
    }
  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 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."));
    }

  if (*s == ',')
    ++s;

  /* Fetch the search string.  */

  while (*s != '\0')
    {
      LONGEST x;
      struct type *t;
      ULONGEST pattern_buf_size_need;

      s = skip_spaces (s);

      v = parse_to_comma_and_eval (&s);
      t = value_type (v);

      /* Keep it simple and assume size == 'g' when watching for when we
	 need to grow the pattern buf.  */
      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 = pattern_buf_size_need * 2;
	  pattern_buf = xrealloc (pattern_buf, pattern_buf_size);
	  pattern_buf_end = pattern_buf + current_offset;
	}

      if (size != '\0')
	{
	  x = value_as_long (v);
	  switch (size)
	    {
	    case 'b':
	      *pattern_buf_end++ = x;
	      break;
	    case 'h':
	      put_bits (x, pattern_buf_end, 16, big_p);
	      pattern_buf_end += sizeof (int16_t);
	      break;
	    case 'w':
	      put_bits (x, pattern_buf_end, 32, big_p);
	      pattern_buf_end += sizeof (int32_t);
	      break;
	    case 'g':
	      put_bits (x, pattern_buf_end, 64, big_p);
	      pattern_buf_end += sizeof (int64_t);
	      break;
	    }
	}
      else
	{
	  memcpy (pattern_buf_end, value_contents (v), TYPE_LENGTH (t));
	  pattern_buf_end += TYPE_LENGTH (t);
	}

      if (*s == ',')
	++s;
      s = skip_spaces (s);
    }

  if (pattern_buf_end == pattern_buf)
    error (_("Missing search pattern."));

  pattern_len = pattern_buf_end - pattern_buf;

  if (search_space_len < pattern_len)
    error (_("Search space too small to contain pattern."));

  *max_countp = max_count;
  *pattern_bufp = pattern_buf;
  *pattern_lenp = pattern_len;
  *start_addrp = start_addr;
  *search_space_lenp = search_space_len;

  /* We successfully parsed the arguments, leave the freeing of PATTERN_BUF
     to the caller now.  */
  discard_cleanups (old_cleanups);
}

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;
  gdb_byte *pattern_buf = 0;
  ULONGEST pattern_len = 0;
  CORE_ADDR start_addr = 0;
  ULONGEST search_space_len = 0;
  /* End of command line parameters.  */
  unsigned int found_count;
  CORE_ADDR last_found_addr;
  struct cleanup *old_cleanups;

  parse_find_args (args, &max_count, &pattern_buf, &pattern_len, 
		   &start_addr, &search_space_len, big_p);

  old_cleanups = make_cleanup (free_current_contents, &pattern_buf);

  /* Perform the search.  */

  found_count = 0;
  last_found_addr = 0;

  while (search_space_len >= pattern_len
	 && found_count < max_count)
    {
      /* Offset from start of this iteration to the next iteration.  */
      ULONGEST next_iter_incr;
      CORE_ADDR found_addr;
      int found = target_search_memory (start_addr, search_space_len,
					pattern_buf, pattern_len, &found_addr);

      if (found <= 0)
	break;

      print_address (gdbarch, found_addr, gdb_stdout);
      printf_filtered ("\n");
      ++found_count;
      last_found_addr = found_addr;

      /* Begin next iteration at one byte past this match.  */
      next_iter_incr = (found_addr - start_addr) + 1;

      /* For robustness, we don't let search_space_len go -ve here.  */
      if (search_space_len >= next_iter_incr)
	search_space_len -= next_iter_incr;
      else
	search_space_len = 0;
      start_addr += next_iter_incr;
    }

  /* Record and print the results.  */

  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 (ptr_type, last_found_addr));
    }

  if (found_count == 0)
    printf_filtered ("Pattern not found.\n");
  else
    printf_filtered ("%d pattern%s found.\n", found_count,
		     found_count > 1 ? "s" : "");

  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:\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\
in the current language.\n\
Note that this means for example that in the case of C-like languages\n\
a search for an untyped 0x42 will search for \"(int) 0x42\"\n\
which is typically four bytes.\n\
\n\
The address of the last match is stored as the value of \"$_\".\n\
Convenience variable \"$numfound\" is set to the number of matches."),
	   &cmdlist);
}
Commit	Line	Data
08388c79 DE	1	/* The find command.
08388c79 DE	2
28e7fd62	3	Copyright (C) 2008-2013 Free Software Foundation, Inc.
08388c79 DE	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"
e17c207e	21	#include "arch-utils.h"
08388c79 DE	22	#include <ctype.h>
	23	#include "gdb_string.h"
	24	#include "gdbcmd.h"
	25	#include "value.h"
	26	#include "target.h"
529480d0	27	#include "cli/cli-utils.h"
08388c79 DE	28
	29	/* Copied from bfd_put_bits. */
	30
	31	static void
6221be90	32	put_bits (bfd_uint64_t data, gdb_byte *buf, int bits, bfd_boolean big_p)
08388c79 DE	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,
6221be90	54	gdb_byte *pattern_bufp, ULONGEST pattern_lenp,
e17c207e UW	55	CORE_ADDR start_addrp, ULONGEST search_space_lenp,
e17c207e UW	56	bfd_boolean big_p)
08388c79 DE	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. */
6221be90	62	gdb_byte *pattern_buf;
08388c79 DE	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. */
6221be90	68	gdb_byte *pattern_buf_end;
08388c79 DE	69	ULONGEST pattern_len;
	70	CORE_ADDR start_addr;
	71	ULONGEST search_space_len;
	72	char *s = args;
08388c79 DE	73	struct cleanup *old_cleanups;
	74	struct value *v;
	75
	76	if (args == NULL)
5e1471f5	77	error (_("Missing search parameters."));
08388c79 DE	78
	79	pattern_buf = 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:
5e1471f5	109	error (_("Invalid size granularity."));
08388c79 DE	110	}
	111	}
	112
529480d0	113	s = skip_spaces (s);
08388c79 DE	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;
529480d0	123	s = skip_spaces (s);
08388c79 DE	124
	125	if (*s == '+')
	126	{
	127	LONGEST len;
bb9bcb69	128
08388c79 DE	129	++s;
	130	v = parse_to_comma_and_eval (&s);
	131	len = value_as_long (v);
	132	if (len == 0)
	133	{
5fe41fbf	134	do_cleanups (old_cleanups);
5e1471f5	135	printf_filtered (_("Empty search range.\n"));
08388c79 DE	136	return;
	137	}
	138	if (len < 0)
5e1471f5	139	error (_("Invalid length."));
08388c79 DE	140	/* Watch for overflows. */
	141	if (len > CORE_ADDR_MAX
	142	\|\| (start_addr + len - 1) < start_addr)
5e1471f5	143	error (_("Search space too large."));
08388c79 DE	144	search_space_len = len;
	145	}
	146	else
	147	{
	148	CORE_ADDR end_addr;
bb9bcb69	149
08388c79 DE	150	v = parse_to_comma_and_eval (&s);
	151	end_addr = value_as_address (v);
	152	if (start_addr > end_addr)
177b42fe	153	error (_("Invalid search space, end precedes start."));
08388c79 DE	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)
3e43a32a MS	159	error (_("Overflow in address range "
3e43a32a MS	160	"computation, choose smaller range."));
08388c79 DE	161	}
	162
	163	if (*s == ',')
	164	++s;
	165
	166	/* Fetch the search string. */
	167
	168	while (*s != '\0')
	169	{
	170	LONGEST x;
744a8059	171	struct type *t;
76b83c51	172	ULONGEST pattern_buf_size_need;
08388c79	173
529480d0	174	s = skip_spaces (s);
08388c79 DE	175
08388c79 DE	176	v = parse_to_comma_and_eval (&s);
744a8059	177	t = value_type (v);
08388c79 DE	178
	179	/* Keep it simple and assume size == 'g' when watching for when we
	180	need to grow the pattern buf. */
76b83c51	181	pattern_buf_size_need = (pattern_buf_end - pattern_buf
744a8059	182	+ max (TYPE_LENGTH (t), sizeof (int64_t)));
76b83c51	183	if (pattern_buf_size_need > pattern_buf_size)
08388c79 DE	184	{
08388c79 DE	185	size_t current_offset = pattern_buf_end - pattern_buf;
bb9bcb69	186
76b83c51	187	pattern_buf_size = pattern_buf_size_need * 2;
08388c79 DE	188	pattern_buf = xrealloc (pattern_buf, pattern_buf_size);
	189	pattern_buf_end = pattern_buf + current_offset;
	190	}
	191
	192	if (size != '\0')
	193	{
	194	x = value_as_long (v);
	195	switch (size)
	196	{
	197	case 'b':
	198	*pattern_buf_end++ = x;
	199	break;
	200	case 'h':
	201	put_bits (x, pattern_buf_end, 16, big_p);
	202	pattern_buf_end += sizeof (int16_t);
	203	break;
	204	case 'w':
	205	put_bits (x, pattern_buf_end, 32, big_p);
	206	pattern_buf_end += sizeof (int32_t);
	207	break;
	208	case 'g':
	209	put_bits (x, pattern_buf_end, 64, big_p);
	210	pattern_buf_end += sizeof (int64_t);
	211	break;
	212	}
	213	}
	214	else
	215	{
744a8059 SP	216	memcpy (pattern_buf_end, value_contents (v), TYPE_LENGTH (t));
744a8059 SP	217	pattern_buf_end += TYPE_LENGTH (t);
08388c79 DE	218	}
	219
	220	if (*s == ',')
	221	++s;
529480d0	222	s = skip_spaces (s);
08388c79 DE	223	}
	224
	225	if (pattern_buf_end == pattern_buf)
5e1471f5	226	error (_("Missing search pattern."));
08388c79 DE	227
	228	pattern_len = pattern_buf_end - pattern_buf;
	229
	230	if (search_space_len < pattern_len)
5e1471f5	231	error (_("Search space too small to contain pattern."));
08388c79 DE	232
	233	*max_countp = max_count;
	234	*pattern_bufp = pattern_buf;
	235	*pattern_lenp = pattern_len;
	236	*start_addrp = start_addr;
	237	*search_space_lenp = search_space_len;
	238
	239	/* We successfully parsed the arguments, leave the freeing of PATTERN_BUF
	240	to the caller now. */
	241	discard_cleanups (old_cleanups);
	242	}
	243
	244	static void
	245	find_command (char *args, int from_tty)
	246	{
e17c207e UW	247	struct gdbarch *gdbarch = get_current_arch ();
e17c207e UW	248	bfd_boolean big_p = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG;
08388c79 DE	249	/* Command line parameters.
	250	These are initialized to avoid uninitialized warnings from -Wall. */
	251	ULONGEST max_count = 0;
6221be90	252	gdb_byte *pattern_buf = 0;
08388c79 DE	253	ULONGEST pattern_len = 0;
	254	CORE_ADDR start_addr = 0;
	255	ULONGEST search_space_len = 0;
	256	/* End of command line parameters. */
	257	unsigned int found_count;
	258	CORE_ADDR last_found_addr;
	259	struct cleanup *old_cleanups;
	260
	261	parse_find_args (args, &max_count, &pattern_buf, &pattern_len,
e17c207e	262	&start_addr, &search_space_len, big_p);
08388c79 DE	263
	264	old_cleanups = make_cleanup (free_current_contents, &pattern_buf);
	265
	266	/* Perform the search. */
	267
	268	found_count = 0;
	269	last_found_addr = 0;
	270
	271	while (search_space_len >= pattern_len
	272	&& found_count < max_count)
	273	{
	274	/* Offset from start of this iteration to the next iteration. */
	275	ULONGEST next_iter_incr;
	276	CORE_ADDR found_addr;
	277	int found = target_search_memory (start_addr, search_space_len,
	278	pattern_buf, pattern_len, &found_addr);
	279
	280	if (found <= 0)
	281	break;
	282
5af949e3	283	print_address (gdbarch, found_addr, gdb_stdout);
08388c79 DE	284	printf_filtered ("\n");
	285	++found_count;
	286	last_found_addr = found_addr;
	287
	288	/* Begin next iteration at one byte past this match. */
	289	next_iter_incr = (found_addr - start_addr) + 1;
	290
	291	/* For robustness, we don't let search_space_len go -ve here. */
	292	if (search_space_len >= next_iter_incr)
	293	search_space_len -= next_iter_incr;
	294	else
	295	search_space_len = 0;
	296	start_addr += next_iter_incr;
	297	}
	298
	299	/* Record and print the results. */
	300
4fa62494	301	set_internalvar_integer (lookup_internalvar ("numfound"), found_count);
08388c79 DE	302	if (found_count > 0)
08388c79 DE	303	{
8b9b9e1a	304	struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
bb9bcb69	305
08388c79	306	set_internalvar (lookup_internalvar ("_"),
8b9b9e1a	307	value_from_pointer (ptr_type, last_found_addr));
08388c79 DE	308	}
	309
	310	if (found_count == 0)
5e1471f5	311	printf_filtered ("Pattern not found.\n");
08388c79	312	else
5e1471f5	313	printf_filtered ("%d pattern%s found.\n", found_count,
08388c79 DE	314	found_count > 1 ? "s" : "");
	315
	316	do_cleanups (old_cleanups);
	317	}
	318
2c0b251b PA	319	/* Provide a prototype to silence -Wmissing-prototypes. */
	320	extern initialize_file_ftype _initialize_mem_search;
	321
08388c79 DE	322	void
	323	_initialize_mem_search (void)
	324	{
	325	add_cmd ("find", class_vars, find_command, _("\
	326	Search memory for a sequence of bytes.\n\
3e43a32a MS	327	Usage:\nfind \
3e43a32a MS	328	[/size-char] [/max-count] start-address, end-address, expr1 [, expr2 ...]\n\
08388c79 DE	329	find [/size-char] [/max-count] start-address, +length, expr1 [, expr2 ...]\n\
	330	size-char is one of b,h,w,g for 8,16,32,64 bit values respectively,\n\
	331	and if not specified the size is taken from the type of the expression\n\
	332	in the current language.\n\
	333	Note that this means for example that in the case of C-like languages\n\
	334	a search for an untyped 0x42 will search for \"(int) 0x42\"\n\
	335	which is typically four bytes.\n\
	336	\n\
	337	The address of the last match is stored as the value of \"$_\".\n\
	338	Convenience variable \"$numfound\" is set to the number of matches."),
	339	&cmdlist);
	340	}