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