1 /* Core dump and executable file functions above target vector, for GDB. 2 3 Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 4 1999, 2000, 2001, 2003, 2006, 2007, 2008, 2009, 2010, 2011 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "gdb_string.h" 24 #include <errno.h> 25 #include <signal.h> 26 #include <fcntl.h> 27 #include "inferior.h" 28 #include "symtab.h" 29 #include "command.h" 30 #include "gdbcmd.h" 31 #include "bfd.h" 32 #include "target.h" 33 #include "gdbcore.h" 34 #include "dis-asm.h" 35 #include "gdb_stat.h" 36 #include "completer.h" 37 #include "exceptions.h" 38 39 /* Local function declarations. */ 40 41 extern void _initialize_core (void); 42 static void call_extra_exec_file_hooks (char *filename); 43 44 /* You can have any number of hooks for `exec_file_command' command to 45 call. If there's only one hook, it is set in exec_file_display 46 hook. If there are two or more hooks, they are set in 47 exec_file_extra_hooks[], and deprecated_exec_file_display_hook is 48 set to a function that calls all of them. This extra complexity is 49 needed to preserve compatibility with old code that assumed that 50 only one hook could be set, and which called 51 deprecated_exec_file_display_hook directly. */ 52 53 typedef void (*hook_type) (char *); 54 55 hook_type deprecated_exec_file_display_hook; /* The original hook. */ 56 static hook_type *exec_file_extra_hooks; /* Array of additional 57 hooks. */ 58 static int exec_file_hook_count = 0; /* Size of array. */ 59 60 /* Binary file diddling handle for the core file. */ 61 62 bfd *core_bfd = NULL; 63 64 /* corelow.c target (if included for this gdb target). */ 65 66 struct target_ops *core_target; 67 68 69 /* Backward compatability with old way of specifying core files. */ 70 71 void 72 core_file_command (char *filename, int from_tty) 73 { 74 dont_repeat (); /* Either way, seems bogus. */ 75 76 if (core_target == NULL) 77 error (_("GDB can't read core files on this machine.")); 78 79 if (!filename) 80 (core_target->to_detach) (core_target, filename, from_tty); 81 else 82 (core_target->to_open) (filename, from_tty); 83 } 84 85 86 /* If there are two or more functions that wish to hook into 87 exec_file_command, this function will call all of the hook 88 functions. */ 89 90 static void 91 call_extra_exec_file_hooks (char *filename) 92 { 93 int i; 94 95 for (i = 0; i < exec_file_hook_count; i++) 96 (*exec_file_extra_hooks[i]) (filename); 97 } 98 99 /* Call this to specify the hook for exec_file_command to call back. 100 This is called from the x-window display code. */ 101 102 void 103 specify_exec_file_hook (void (*hook) (char *)) 104 { 105 hook_type *new_array; 106 107 if (deprecated_exec_file_display_hook != NULL) 108 { 109 /* There's already a hook installed. Arrange to have both it 110 and the subsequent hooks called. */ 111 if (exec_file_hook_count == 0) 112 { 113 /* If this is the first extra hook, initialize the hook 114 array. */ 115 exec_file_extra_hooks = (hook_type *) 116 xmalloc (sizeof (hook_type)); 117 exec_file_extra_hooks[0] = deprecated_exec_file_display_hook; 118 deprecated_exec_file_display_hook = call_extra_exec_file_hooks; 119 exec_file_hook_count = 1; 120 } 121 122 /* Grow the hook array by one and add the new hook to the end. 123 Yes, it's inefficient to grow it by one each time but since 124 this is hardly ever called it's not a big deal. */ 125 exec_file_hook_count++; 126 new_array = (hook_type *) 127 xrealloc (exec_file_extra_hooks, 128 exec_file_hook_count * sizeof (hook_type)); 129 exec_file_extra_hooks = new_array; 130 exec_file_extra_hooks[exec_file_hook_count - 1] = hook; 131 } 132 else 133 deprecated_exec_file_display_hook = hook; 134 } 135 136 /* The exec file must be closed before running an inferior. 137 If it is needed again after the inferior dies, it must 138 be reopened. */ 139 140 void 141 close_exec_file (void) 142 { 143 #if 0 /* FIXME */ 144 if (exec_bfd) 145 bfd_tempclose (exec_bfd); 146 #endif 147 } 148 149 void 150 reopen_exec_file (void) 151 { 152 #if 0 /* FIXME */ 153 if (exec_bfd) 154 bfd_reopen (exec_bfd); 155 #else 156 char *filename; 157 int res; 158 struct stat st; 159 struct cleanup *cleanups; 160 161 /* Don't do anything if there isn't an exec file. */ 162 if (exec_bfd == NULL) 163 return; 164 165 /* If the timestamp of the exec file has changed, reopen it. */ 166 filename = xstrdup (bfd_get_filename (exec_bfd)); 167 cleanups = make_cleanup (xfree, filename); 168 res = stat (filename, &st); 169 170 if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime) 171 exec_file_attach (filename, 0); 172 else 173 /* If we accessed the file since last opening it, close it now; 174 this stops GDB from holding the executable open after it 175 exits. */ 176 bfd_cache_close_all (); 177 178 do_cleanups (cleanups); 179 #endif 180 } 181 182 /* If we have both a core file and an exec file, 183 print a warning if they don't go together. */ 184 185 void 186 validate_files (void) 187 { 188 if (exec_bfd && core_bfd) 189 { 190 if (!core_file_matches_executable_p (core_bfd, exec_bfd)) 191 warning (_("core file may not match specified executable file.")); 192 else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd)) 193 warning (_("exec file is newer than core file.")); 194 } 195 } 196 197 /* Return the name of the executable file as a string. 198 ERR nonzero means get error if there is none specified; 199 otherwise return 0 in that case. */ 200 201 char * 202 get_exec_file (int err) 203 { 204 if (exec_bfd) 205 return bfd_get_filename (exec_bfd); 206 if (!err) 207 return NULL; 208 209 error (_("No executable file specified.\n\ 210 Use the \"file\" or \"exec-file\" command.")); 211 return NULL; 212 } 213 214 215 /* Report a memory error by throwing a MEMORY_ERROR error. */ 216 217 void 218 memory_error (int status, CORE_ADDR memaddr) 219 { 220 if (status == EIO) 221 /* Actually, address between memaddr and memaddr + len was out of 222 bounds. */ 223 throw_error (MEMORY_ERROR, 224 _("Cannot access memory at address %s"), 225 paddress (target_gdbarch, memaddr)); 226 else 227 throw_error (MEMORY_ERROR, 228 _("Error accessing memory address %s: %s."), 229 paddress (target_gdbarch, memaddr), 230 safe_strerror (status)); 231 } 232 233 /* Same as target_read_memory, but report an error if can't read. */ 234 235 void 236 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len) 237 { 238 int status; 239 240 status = target_read_memory (memaddr, myaddr, len); 241 if (status != 0) 242 memory_error (status, memaddr); 243 } 244 245 /* Same as target_read_stack, but report an error if can't read. */ 246 247 void 248 read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len) 249 { 250 int status; 251 252 status = target_read_stack (memaddr, myaddr, len); 253 if (status != 0) 254 memory_error (status, memaddr); 255 } 256 257 /* Argument / return result struct for use with 258 do_captured_read_memory_integer(). MEMADDR and LEN are filled in 259 by gdb_read_memory_integer(). RESULT is the contents that were 260 successfully read from MEMADDR of length LEN. */ 261 262 struct captured_read_memory_integer_arguments 263 { 264 CORE_ADDR memaddr; 265 int len; 266 enum bfd_endian byte_order; 267 LONGEST result; 268 }; 269 270 /* Helper function for gdb_read_memory_integer(). DATA must be a 271 pointer to a captured_read_memory_integer_arguments struct. 272 Return 1 if successful. Note that the catch_errors() interface 273 will return 0 if an error occurred while reading memory. This 274 choice of return code is so that we can distinguish between 275 success and failure. */ 276 277 static int 278 do_captured_read_memory_integer (void *data) 279 { 280 struct captured_read_memory_integer_arguments *args 281 = (struct captured_read_memory_integer_arguments*) data; 282 CORE_ADDR memaddr = args->memaddr; 283 int len = args->len; 284 enum bfd_endian byte_order = args->byte_order; 285 286 args->result = read_memory_integer (memaddr, len, byte_order); 287 288 return 1; 289 } 290 291 /* Read memory at MEMADDR of length LEN and put the contents in 292 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero 293 if successful. */ 294 295 int 296 safe_read_memory_integer (CORE_ADDR memaddr, int len, 297 enum bfd_endian byte_order, 298 LONGEST *return_value) 299 { 300 int status; 301 struct captured_read_memory_integer_arguments args; 302 303 args.memaddr = memaddr; 304 args.len = len; 305 args.byte_order = byte_order; 306 307 status = catch_errors (do_captured_read_memory_integer, &args, 308 "", RETURN_MASK_ALL); 309 if (status) 310 *return_value = args.result; 311 312 return status; 313 } 314 315 LONGEST 316 read_memory_integer (CORE_ADDR memaddr, int len, 317 enum bfd_endian byte_order) 318 { 319 gdb_byte buf[sizeof (LONGEST)]; 320 321 read_memory (memaddr, buf, len); 322 return extract_signed_integer (buf, len, byte_order); 323 } 324 325 ULONGEST 326 read_memory_unsigned_integer (CORE_ADDR memaddr, int len, 327 enum bfd_endian byte_order) 328 { 329 gdb_byte buf[sizeof (ULONGEST)]; 330 331 read_memory (memaddr, buf, len); 332 return extract_unsigned_integer (buf, len, byte_order); 333 } 334 335 void 336 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len) 337 { 338 char *cp; 339 int i; 340 int cnt; 341 342 cp = buffer; 343 while (1) 344 { 345 if (cp - buffer >= max_len) 346 { 347 buffer[max_len - 1] = '\0'; 348 break; 349 } 350 cnt = max_len - (cp - buffer); 351 if (cnt > 8) 352 cnt = 8; 353 read_memory (memaddr + (int) (cp - buffer), cp, cnt); 354 for (i = 0; i < cnt && *cp; i++, cp++) 355 ; /* null body */ 356 357 if (i < cnt && !*cp) 358 break; 359 } 360 } 361 362 CORE_ADDR 363 read_memory_typed_address (CORE_ADDR addr, struct type *type) 364 { 365 gdb_byte *buf = alloca (TYPE_LENGTH (type)); 366 367 read_memory (addr, buf, TYPE_LENGTH (type)); 368 return extract_typed_address (buf, type); 369 } 370 371 /* Same as target_write_memory, but report an error if can't 372 write. */ 373 void 374 write_memory (CORE_ADDR memaddr, 375 const bfd_byte *myaddr, int len) 376 { 377 int status; 378 379 status = target_write_memory (memaddr, myaddr, len); 380 if (status != 0) 381 memory_error (status, memaddr); 382 } 383 384 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned 385 integer. */ 386 void 387 write_memory_unsigned_integer (CORE_ADDR addr, int len, 388 enum bfd_endian byte_order, 389 ULONGEST value) 390 { 391 gdb_byte *buf = alloca (len); 392 393 store_unsigned_integer (buf, len, byte_order, value); 394 write_memory (addr, buf, len); 395 } 396 397 /* Store VALUE at ADDR in the inferior as a LEN-byte signed 398 integer. */ 399 void 400 write_memory_signed_integer (CORE_ADDR addr, int len, 401 enum bfd_endian byte_order, 402 LONGEST value) 403 { 404 gdb_byte *buf = alloca (len); 405 406 store_signed_integer (buf, len, byte_order, value); 407 write_memory (addr, buf, len); 408 } 409 410 /* The current default bfd target. Points to storage allocated for 411 gnutarget_string. */ 412 char *gnutarget; 413 414 /* Same thing, except it is "auto" not NULL for the default case. */ 415 static char *gnutarget_string; 416 static void 417 show_gnutarget_string (struct ui_file *file, int from_tty, 418 struct cmd_list_element *c, 419 const char *value) 420 { 421 fprintf_filtered (file, 422 _("The current BFD target is \"%s\".\n"), value); 423 } 424 425 static void set_gnutarget_command (char *, int, 426 struct cmd_list_element *); 427 428 static void 429 set_gnutarget_command (char *ignore, int from_tty, 430 struct cmd_list_element *c) 431 { 432 if (strcmp (gnutarget_string, "auto") == 0) 433 gnutarget = NULL; 434 else 435 gnutarget = gnutarget_string; 436 } 437 438 /* Set the gnutarget. */ 439 void 440 set_gnutarget (char *newtarget) 441 { 442 if (gnutarget_string != NULL) 443 xfree (gnutarget_string); 444 gnutarget_string = xstrdup (newtarget); 445 set_gnutarget_command (NULL, 0, NULL); 446 } 447 448 void 449 _initialize_core (void) 450 { 451 struct cmd_list_element *c; 452 453 c = add_cmd ("core-file", class_files, core_file_command, _("\ 454 Use FILE as core dump for examining memory and registers.\n\ 455 No arg means have no core file. This command has been superseded by the\n\ 456 `target core' and `detach' commands."), &cmdlist); 457 set_cmd_completer (c, filename_completer); 458 459 460 add_setshow_string_noescape_cmd ("gnutarget", class_files, 461 &gnutarget_string, _("\ 462 Set the current BFD target."), _("\ 463 Show the current BFD target."), _("\ 464 Use `set gnutarget auto' to specify automatic detection."), 465 set_gnutarget_command, 466 show_gnutarget_string, 467 &setlist, &showlist); 468 469 if (getenv ("GNUTARGET")) 470 set_gnutarget (getenv ("GNUTARGET")); 471 else 472 set_gnutarget ("auto"); 473 } 474