1 /* The find command. 2 3 Copyright (C) 2008-2012 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 130 ++s; 131 v = parse_to_comma_and_eval (&s); 132 len = value_as_long (v); 133 if (len == 0) 134 { 135 do_cleanups (old_cleanups); 136 printf_filtered (_("Empty search range.\n")); 137 return; 138 } 139 if (len < 0) 140 error (_("Invalid length.")); 141 /* Watch for overflows. */ 142 if (len > CORE_ADDR_MAX 143 || (start_addr + len - 1) < start_addr) 144 error (_("Search space too large.")); 145 search_space_len = len; 146 } 147 else 148 { 149 CORE_ADDR end_addr; 150 151 v = parse_to_comma_and_eval (&s); 152 end_addr = value_as_address (v); 153 if (start_addr > end_addr) 154 error (_("Invalid search space, end precedes start.")); 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) 160 error (_("Overflow in address range " 161 "computation, choose smaller range.")); 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; 186 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 { 216 memcpy (pattern_buf_end, value_contents (v), val_bytes); 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) 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 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, 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 /* Provide a prototype to silence -Wmissing-prototypes. */ 321 extern initialize_file_ftype _initialize_mem_search; 322 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\ 328 Usage:\nfind \ 329 [/size-char] [/max-count] start-address, end-address, expr1 [, expr2 ...]\n\ 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 } 342