1 /* The find command. 2 3 Copyright (C) 2008, 2009, 2010, 2011 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 printf_filtered (_("Empty search range.\n")); 136 return; 137 } 138 if (len < 0) 139 error (_("Invalid length.")); 140 /* Watch for overflows. */ 141 if (len > CORE_ADDR_MAX 142 || (start_addr + len - 1) < start_addr) 143 error (_("Search space too large.")); 144 search_space_len = len; 145 } 146 else 147 { 148 CORE_ADDR end_addr; 149 150 v = parse_to_comma_and_eval (&s); 151 end_addr = value_as_address (v); 152 if (start_addr > end_addr) 153 error (_("Invalid search space, end preceeds start.")); 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) 159 error (_("Overflow in address range " 160 "computation, choose smaller range.")); 161 } 162 163 if (*s == ',') 164 ++s; 165 166 /* Fetch the search string. */ 167 168 while (*s != '\0') 169 { 170 LONGEST x; 171 int val_bytes; 172 173 while (isspace (*s)) 174 ++s; 175 176 v = parse_to_comma_and_eval (&s); 177 val_bytes = TYPE_LENGTH (value_type (v)); 178 179 /* Keep it simple and assume size == 'g' when watching for when we 180 need to grow the pattern buf. */ 181 if ((pattern_buf_end - pattern_buf + max (val_bytes, sizeof (int64_t))) 182 > pattern_buf_size) 183 { 184 size_t current_offset = pattern_buf_end - pattern_buf; 185 186 pattern_buf_size *= 2; 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 { 215 memcpy (pattern_buf_end, value_contents (v), val_bytes); 216 pattern_buf_end += val_bytes; 217 } 218 219 if (*s == ',') 220 ++s; 221 while (isspace (*s)) 222 ++s; 223 } 224 225 if (pattern_buf_end == pattern_buf) 226 error (_("Missing search pattern.")); 227 228 pattern_len = pattern_buf_end - pattern_buf; 229 230 if (search_space_len < pattern_len) 231 error (_("Search space too small to contain pattern.")); 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 { 247 struct gdbarch *gdbarch = get_current_arch (); 248 bfd_boolean big_p = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG; 249 /* Command line parameters. 250 These are initialized to avoid uninitialized warnings from -Wall. */ 251 ULONGEST max_count = 0; 252 char *pattern_buf = 0; 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, 262 &start_addr, &search_space_len, big_p); 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 283 print_address (gdbarch, found_addr, gdb_stdout); 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 301 set_internalvar_integer (lookup_internalvar ("numfound"), found_count); 302 if (found_count > 0) 303 { 304 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 305 306 set_internalvar (lookup_internalvar ("_"), 307 value_from_pointer (ptr_type, last_found_addr)); 308 } 309 310 if (found_count == 0) 311 printf_filtered ("Pattern not found.\n"); 312 else 313 printf_filtered ("%d pattern%s found.\n", found_count, 314 found_count > 1 ? "s" : ""); 315 316 do_cleanups (old_cleanups); 317 } 318 319 /* Provide a prototype to silence -Wmissing-prototypes. */ 320 extern initialize_file_ftype _initialize_mem_search; 321 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\ 327 Usage:\nfind \ 328 [/size-char] [/max-count] start-address, end-address, expr1 [, expr2 ...]\n\ 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 } 341