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

/* The find command.

   Copyright (C) 2008, 2009, 2010, 2011 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"

/* Copied from bfd_put_bits.  */

static void
put_bits (bfd_uint64_t data, char *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,
		 char **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.  */
  char *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.  */
  char *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."));
	    }
	}

      while (isspace (*s))
	++s;
    }

  /* Get the search range.  */

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

  if (*s == ',')
    ++s;
  while (isspace (*s))
    ++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;
      int val_bytes;

      while (isspace (*s))
	++s;

      v = parse_to_comma_and_eval (&s);
      val_bytes = TYPE_LENGTH (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)
	{
	  size_t current_offset = pattern_buf_end - pattern_buf;

	  pattern_buf_size *= 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), val_bytes);
	  pattern_buf_end += val_bytes;
	}

      if (*s == ',')
	++s;
      while (isspace (*s))
	++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;
  char *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
7b6bb8da	3	Copyright (C) 2008, 2009, 2010, 2011 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"
	27
	28	/* Copied from bfd_put_bits. */
	29
	30	static void
	31	put_bits (bfd_uint64_t data, char *buf, int bits, bfd_boolean big_p)
	32	{
	33	int i;
	34	int bytes;
	35
	36	gdb_assert (bits % 8 == 0);
	37
	38	bytes = bits / 8;
	39	for (i = 0; i < bytes; i++)
	40	{
	41	int index = big_p ? bytes - i - 1 : i;
	42
	43	buf[index] = data & 0xff;
	44	data >>= 8;
	45	}
	46	}
	47
	48	/* Subroutine of find_command to simplify it.
	49	Parse the arguments of the "find" command. */
	50
	51	static void
	52	parse_find_args (char args, ULONGEST max_countp,
	53	char *pattern_bufp, ULONGEST pattern_lenp,
e17c207e UW	54	CORE_ADDR start_addrp, ULONGEST search_space_lenp,
e17c207e UW	55	bfd_boolean big_p)
08388c79 DE	56	{
	57	/* Default to using the specified type. */
	58	char size = '\0';
	59	ULONGEST max_count = ~(ULONGEST) 0;
	60	/* Buffer to hold the search pattern. */
	61	char *pattern_buf;
	62	/* Current size of search pattern buffer.
	63	We realloc space as needed. */
	64	#define INITIAL_PATTERN_BUF_SIZE 100
	65	ULONGEST pattern_buf_size = INITIAL_PATTERN_BUF_SIZE;
	66	/* Pointer to one past the last in-use part of pattern_buf. */
	67	char *pattern_buf_end;
	68	ULONGEST pattern_len;
	69	CORE_ADDR start_addr;
	70	ULONGEST search_space_len;
	71	char *s = args;
08388c79 DE	72	struct cleanup *old_cleanups;
	73	struct value *v;
	74
	75	if (args == NULL)
5e1471f5	76	error (_("Missing search parameters."));
08388c79 DE	77
	78	pattern_buf = xmalloc (pattern_buf_size);
	79	pattern_buf_end = pattern_buf;
	80	old_cleanups = make_cleanup (free_current_contents, &pattern_buf);
	81
	82	/* Get search granularity and/or max count if specified.
	83	They may be specified in either order, together or separately. */
	84
	85	while (*s == '/')
	86	{
	87	++s;
	88
	89	while (s != '\0' && s != '/' && !isspace (*s))
	90	{
	91	if (isdigit (*s))
	92	{
	93	max_count = atoi (s);
	94	while (isdigit (*s))
	95	++s;
	96	continue;
	97	}
	98
	99	switch (*s)
	100	{
	101	case 'b':
	102	case 'h':
	103	case 'w':
	104	case 'g':
	105	size = *s++;
	106	break;
	107	default:
5e1471f5	108	error (_("Invalid size granularity."));
08388c79 DE	109	}
	110	}
	111
	112	while (isspace (*s))
	113	++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	while (isspace (*s))
	124	++s;
	125
	126	if (*s == '+')
	127	{
	128	LONGEST len;
bb9bcb69	129
08388c79 DE	130	++s;
	131	v = parse_to_comma_and_eval (&s);
	132	len = value_as_long (v);
	133	if (len == 0)
	134	{
5fe41fbf	135	do_cleanups (old_cleanups);
5e1471f5	136	printf_filtered (_("Empty search range.\n"));
08388c79 DE	137	return;
	138	}
	139	if (len < 0)
5e1471f5	140	error (_("Invalid length."));
08388c79 DE	141	/* Watch for overflows. */
	142	if (len > CORE_ADDR_MAX
	143	\|\| (start_addr + len - 1) < start_addr)
5e1471f5	144	error (_("Search space too large."));
08388c79 DE	145	search_space_len = len;
	146	}
	147	else
	148	{
	149	CORE_ADDR end_addr;
bb9bcb69	150
08388c79 DE	151	v = parse_to_comma_and_eval (&s);
	152	end_addr = value_as_address (v);
	153	if (start_addr > end_addr)
177b42fe	154	error (_("Invalid search space, end precedes start."));
08388c79 DE	155	search_space_len = end_addr - start_addr + 1;
	156	/* We don't support searching all of memory
	157	(i.e. start=0, end = 0xff..ff).
	158	Bail to avoid overflows later on. */
	159	if (search_space_len == 0)
3e43a32a MS	160	error (_("Overflow in address range "
3e43a32a MS	161	"computation, choose smaller range."));
08388c79 DE	162	}
	163
	164	if (*s == ',')
	165	++s;
	166
	167	/* Fetch the search string. */
	168
	169	while (*s != '\0')
	170	{
	171	LONGEST x;
	172	int val_bytes;
	173
	174	while (isspace (*s))
	175	++s;
	176
	177	v = parse_to_comma_and_eval (&s);
	178	val_bytes = TYPE_LENGTH (value_type (v));
	179
	180	/* Keep it simple and assume size == 'g' when watching for when we
	181	need to grow the pattern buf. */
	182	if ((pattern_buf_end - pattern_buf + max (val_bytes, sizeof (int64_t)))
	183	> pattern_buf_size)
	184	{
	185	size_t current_offset = pattern_buf_end - pattern_buf;
bb9bcb69	186
08388c79 DE	187	pattern_buf_size *= 2;
	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	{
7ecb917e	216	memcpy (pattern_buf_end, value_contents (v), val_bytes);
08388c79 DE	217	pattern_buf_end += val_bytes;
	218	}
	219
	220	if (*s == ',')
	221	++s;
	222	while (isspace (*s))
	223	++s;
	224	}
	225
	226	if (pattern_buf_end == pattern_buf)
5e1471f5	227	error (_("Missing search pattern."));
08388c79 DE	228
	229	pattern_len = pattern_buf_end - pattern_buf;
	230
	231	if (search_space_len < pattern_len)
5e1471f5	232	error (_("Search space too small to contain pattern."));
08388c79 DE	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	{
e17c207e UW	248	struct gdbarch *gdbarch = get_current_arch ();
e17c207e UW	249	bfd_boolean big_p = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG;
08388c79 DE	250	/* Command line parameters.
	251	These are initialized to avoid uninitialized warnings from -Wall. */
	252	ULONGEST max_count = 0;
	253	char *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,
e17c207e	263	&start_addr, &search_space_len, big_p);
08388c79 DE	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
5af949e3	284	print_address (gdbarch, found_addr, gdb_stdout);
08388c79 DE	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
4fa62494	302	set_internalvar_integer (lookup_internalvar ("numfound"), found_count);
08388c79 DE	303	if (found_count > 0)
08388c79 DE	304	{
8b9b9e1a	305	struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
bb9bcb69	306
08388c79	307	set_internalvar (lookup_internalvar ("_"),
8b9b9e1a	308	value_from_pointer (ptr_type, last_found_addr));
08388c79 DE	309	}
	310
	311	if (found_count == 0)
5e1471f5	312	printf_filtered ("Pattern not found.\n");
08388c79	313	else
5e1471f5	314	printf_filtered ("%d pattern%s found.\n", found_count,
08388c79 DE	315	found_count > 1 ? "s" : "");
	316
	317	do_cleanups (old_cleanups);
	318	}
	319
2c0b251b PA	320	/* Provide a prototype to silence -Wmissing-prototypes. */
	321	extern initialize_file_ftype _initialize_mem_search;
	322
08388c79 DE	323	void
	324	_initialize_mem_search (void)
	325	{
	326	add_cmd ("find", class_vars, find_command, _("\
	327	Search memory for a sequence of bytes.\n\
3e43a32a MS	328	Usage:\nfind \
3e43a32a MS	329	[/size-char] [/max-count] start-address, end-address, expr1 [, expr2 ...]\n\
08388c79 DE	330	find [/size-char] [/max-count] start-address, +length, expr1 [, expr2 ...]\n\
	331	size-char is one of b,h,w,g for 8,16,32,64 bit values respectively,\n\
	332	and if not specified the size is taken from the type of the expression\n\
	333	in the current language.\n\
	334	Note that this means for example that in the case of C-like languages\n\
	335	a search for an untyped 0x42 will search for \"(int) 0x42\"\n\
	336	which is typically four bytes.\n\
	337	\n\
	338	The address of the last match is stored as the value of \"$_\".\n\
	339	Convenience variable \"$numfound\" is set to the number of matches."),
	340	&cmdlist);
	341	}