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