1 /* The find command. 2 3 Copyright (C) 2008-2016 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 "gdbcmd.h" 24 #include "value.h" 25 #include "target.h" 26 #include "cli/cli-utils.h" 27 28 /* Copied from bfd_put_bits. */ 29 30 static void 31 put_bits (bfd_uint64_t data, gdb_byte *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 gdb_byte **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 gdb_byte *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 gdb_byte *pattern_buf_end; 68 ULONGEST pattern_len; 69 CORE_ADDR start_addr; 70 ULONGEST search_space_len; 71 const 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 = (gdb_byte *) 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 s = skip_spaces_const (s); 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; 122 s = skip_spaces_const (s); 123 124 if (*s == '+') 125 { 126 LONGEST len; 127 128 ++s; 129 v = parse_to_comma_and_eval (&s); 130 len = value_as_long (v); 131 if (len == 0) 132 { 133 do_cleanups (old_cleanups); 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 149 v = parse_to_comma_and_eval (&s); 150 end_addr = value_as_address (v); 151 if (start_addr > end_addr) 152 error (_("Invalid search space, end precedes start.")); 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) 158 error (_("Overflow in address range " 159 "computation, choose smaller range.")); 160 } 161 162 if (*s == ',') 163 ++s; 164 165 /* Fetch the search string. */ 166 167 while (*s != '\0') 168 { 169 LONGEST x; 170 struct type *t; 171 ULONGEST pattern_buf_size_need; 172 173 s = skip_spaces_const (s); 174 175 v = parse_to_comma_and_eval (&s); 176 t = value_type (v); 177 178 /* Keep it simple and assume size == 'g' when watching for when we 179 need to grow the pattern buf. */ 180 pattern_buf_size_need = (pattern_buf_end - pattern_buf 181 + max (TYPE_LENGTH (t), sizeof (int64_t))); 182 if (pattern_buf_size_need > pattern_buf_size) 183 { 184 size_t current_offset = pattern_buf_end - pattern_buf; 185 186 pattern_buf_size = pattern_buf_size_need * 2; 187 pattern_buf = (gdb_byte *) 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), TYPE_LENGTH (t)); 216 pattern_buf_end += TYPE_LENGTH (t); 217 } 218 219 if (*s == ',') 220 ++s; 221 s = skip_spaces_const (s); 222 } 223 224 if (pattern_buf_end == pattern_buf) 225 error (_("Missing search pattern.")); 226 227 pattern_len = pattern_buf_end - pattern_buf; 228 229 if (search_space_len < pattern_len) 230 error (_("Search space too small to contain pattern.")); 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 { 246 struct gdbarch *gdbarch = get_current_arch (); 247 bfd_boolean big_p = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG; 248 /* Command line parameters. 249 These are initialized to avoid uninitialized warnings from -Wall. */ 250 ULONGEST max_count = 0; 251 gdb_byte *pattern_buf = 0; 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, 261 &start_addr, &search_space_len, big_p); 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 282 print_address (gdbarch, found_addr, gdb_stdout); 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 300 set_internalvar_integer (lookup_internalvar ("numfound"), found_count); 301 if (found_count > 0) 302 { 303 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 304 305 set_internalvar (lookup_internalvar ("_"), 306 value_from_pointer (ptr_type, last_found_addr)); 307 } 308 309 if (found_count == 0) 310 printf_filtered ("Pattern not found.\n"); 311 else 312 printf_filtered ("%d pattern%s found.\n", found_count, 313 found_count > 1 ? "s" : ""); 314 315 do_cleanups (old_cleanups); 316 } 317 318 /* Provide a prototype to silence -Wmissing-prototypes. */ 319 extern initialize_file_ftype _initialize_mem_search; 320 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\ 326 Usage:\nfind \ 327 [/size-char] [/max-count] start-address, end-address, expr1 [, expr2 ...]\n\ 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 } 340