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

/* The find command.

   Copyright (C) 2008-2015 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 "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;
  const 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_const (s);
    }

  /* Get the search range.  */

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

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