corefile.c revision 98944
1/* Core dump and executable file functions above target vector, for GDB. 2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 3 1999, 2000, 2001 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 2 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, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23#include "defs.h" 24#include "gdb_string.h" 25#include <errno.h> 26#include <signal.h> 27#include <fcntl.h> 28#include "inferior.h" 29#include "symtab.h" 30#include "command.h" 31#include "gdbcmd.h" 32#include "bfd.h" 33#include "target.h" 34#include "gdbcore.h" 35#include "dis-asm.h" 36#include "gdb_stat.h" 37#include "completer.h" 38 39/* Local function declarations. */ 40 41extern void _initialize_core (void); 42static void call_extra_exec_file_hooks (char *filename); 43 44/* You can have any number of hooks for `exec_file_command' command to call. 45 If there's only one hook, it is set in exec_file_display hook. 46 If there are two or more hooks, they are set in exec_file_extra_hooks[], 47 and exec_file_display_hook is set to a function that calls all of them. 48 This extra complexity is needed to preserve compatibility with 49 old code that assumed that only one hook could be set, and which called 50 exec_file_display_hook directly. */ 51 52typedef void (*hook_type) (char *); 53 54hook_type exec_file_display_hook; /* the original hook */ 55static hook_type *exec_file_extra_hooks; /* array of additional hooks */ 56static int exec_file_hook_count = 0; /* size of array */ 57 58/* Binary file diddling handle for the core file. */ 59 60bfd *core_bfd = NULL; 61 62 63/* Backward compatability with old way of specifying core files. */ 64 65void 66core_file_command (char *filename, int from_tty) 67{ 68 struct target_ops *t; 69 70 dont_repeat (); /* Either way, seems bogus. */ 71 72 t = find_core_target (); 73 if (t == NULL) 74 error ("GDB can't read core files on this machine."); 75 76 if (!filename) 77 (t->to_detach) (filename, from_tty); 78 else 79 (t->to_open) (filename, from_tty); 80} 81 82 83/* If there are two or more functions that wish to hook into exec_file_command, 84 * this function will call all of the hook functions. */ 85 86static void 87call_extra_exec_file_hooks (char *filename) 88{ 89 int i; 90 91 for (i = 0; i < exec_file_hook_count; i++) 92 (*exec_file_extra_hooks[i]) (filename); 93} 94 95/* Call this to specify the hook for exec_file_command to call back. 96 This is called from the x-window display code. */ 97 98void 99specify_exec_file_hook (void (*hook) (char *)) 100{ 101 hook_type *new_array; 102 103 if (exec_file_display_hook != NULL) 104 { 105 /* There's already a hook installed. Arrange to have both it 106 * and the subsequent hooks called. */ 107 if (exec_file_hook_count == 0) 108 { 109 /* If this is the first extra hook, initialize the hook array. */ 110 exec_file_extra_hooks = (hook_type *) xmalloc (sizeof (hook_type)); 111 exec_file_extra_hooks[0] = exec_file_display_hook; 112 exec_file_display_hook = call_extra_exec_file_hooks; 113 exec_file_hook_count = 1; 114 } 115 116 /* Grow the hook array by one and add the new hook to the end. 117 Yes, it's inefficient to grow it by one each time but since 118 this is hardly ever called it's not a big deal. */ 119 exec_file_hook_count++; 120 new_array = 121 (hook_type *) xrealloc (exec_file_extra_hooks, 122 exec_file_hook_count * sizeof (hook_type)); 123 exec_file_extra_hooks = new_array; 124 exec_file_extra_hooks[exec_file_hook_count - 1] = hook; 125 } 126 else 127 exec_file_display_hook = hook; 128} 129 130/* The exec file must be closed before running an inferior. 131 If it is needed again after the inferior dies, it must 132 be reopened. */ 133 134void 135close_exec_file (void) 136{ 137#if 0 /* FIXME */ 138 if (exec_bfd) 139 bfd_tempclose (exec_bfd); 140#endif 141} 142 143void 144reopen_exec_file (void) 145{ 146#if 0 /* FIXME */ 147 if (exec_bfd) 148 bfd_reopen (exec_bfd); 149#else 150 char *filename; 151 int res; 152 struct stat st; 153 long mtime; 154 155 /* Don't do anything if the current target isn't exec. */ 156 if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0) 157 return; 158 159 /* If the timestamp of the exec file has changed, reopen it. */ 160 filename = xstrdup (bfd_get_filename (exec_bfd)); 161 make_cleanup (xfree, filename); 162 mtime = bfd_get_mtime (exec_bfd); 163 res = stat (filename, &st); 164 165 if (mtime && mtime != st.st_mtime) 166 { 167 exec_open (filename, 0); 168 } 169#endif 170} 171 172/* If we have both a core file and an exec file, 173 print a warning if they don't go together. */ 174 175void 176validate_files (void) 177{ 178 if (exec_bfd && core_bfd) 179 { 180 if (!core_file_matches_executable_p (core_bfd, exec_bfd)) 181 warning ("core file may not match specified executable file."); 182 else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd)) 183 warning ("exec file is newer than core file."); 184 } 185} 186 187/* Return the name of the executable file as a string. 188 ERR nonzero means get error if there is none specified; 189 otherwise return 0 in that case. */ 190 191char * 192get_exec_file (int err) 193{ 194 if (exec_bfd) 195 return bfd_get_filename (exec_bfd); 196 if (!err) 197 return NULL; 198 199 error ("No executable file specified.\n\ 200Use the \"file\" or \"exec-file\" command."); 201 return NULL; 202} 203 204 205/* Report a memory error with error(). */ 206 207void 208memory_error (int status, CORE_ADDR memaddr) 209{ 210 struct ui_file *tmp_stream = mem_fileopen (); 211 make_cleanup_ui_file_delete (tmp_stream); 212 213 if (status == EIO) 214 { 215 /* Actually, address between memaddr and memaddr + len 216 was out of bounds. */ 217 fprintf_unfiltered (tmp_stream, "Cannot access memory at address "); 218 print_address_numeric (memaddr, 1, tmp_stream); 219 } 220 else 221 { 222 fprintf_filtered (tmp_stream, "Error accessing memory address "); 223 print_address_numeric (memaddr, 1, tmp_stream); 224 fprintf_filtered (tmp_stream, ": %s.", 225 safe_strerror (status)); 226 } 227 228 error_stream (tmp_stream); 229} 230 231/* Same as target_read_memory, but report an error if can't read. */ 232void 233read_memory (CORE_ADDR memaddr, char *myaddr, int len) 234{ 235 int status; 236 status = target_read_memory (memaddr, myaddr, len); 237 if (status != 0) 238 memory_error (status, memaddr); 239} 240 241/* Like target_read_memory, but slightly different parameters. */ 242int 243dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len, 244 disassemble_info *info) 245{ 246 return target_read_memory (memaddr, (char *) myaddr, len); 247} 248 249/* Like memory_error with slightly different parameters. */ 250void 251dis_asm_memory_error (int status, bfd_vma memaddr, disassemble_info *info) 252{ 253 memory_error (status, memaddr); 254} 255 256/* Like print_address with slightly different parameters. */ 257void 258dis_asm_print_address (bfd_vma addr, struct disassemble_info *info) 259{ 260 print_address (addr, info->stream); 261} 262 263/* Read an integer from debugged memory, given address and number of bytes. */ 264 265struct captured_read_memory_integer_arguments 266{ 267 CORE_ADDR memaddr; 268 int len; 269 LONGEST result; 270}; 271 272static int 273do_captured_read_memory_integer (void *data) 274{ 275 struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data; 276 CORE_ADDR memaddr = args->memaddr; 277 int len = args->len; 278 279 args->result = read_memory_integer (memaddr, len); 280 281 return 0; 282} 283 284int 285safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value) 286{ 287 int status; 288 struct captured_read_memory_integer_arguments args; 289 args.memaddr = memaddr; 290 args.len = len; 291 292 status = catch_errors (do_captured_read_memory_integer, &args, 293 "", RETURN_MASK_ALL); 294 if (!status) 295 *return_value = args.result; 296 297 return status; 298} 299 300LONGEST 301read_memory_integer (CORE_ADDR memaddr, int len) 302{ 303 char buf[sizeof (LONGEST)]; 304 305 read_memory (memaddr, buf, len); 306 return extract_signed_integer (buf, len); 307} 308 309ULONGEST 310read_memory_unsigned_integer (CORE_ADDR memaddr, int len) 311{ 312 char buf[sizeof (ULONGEST)]; 313 314 read_memory (memaddr, buf, len); 315 return extract_unsigned_integer (buf, len); 316} 317 318void 319read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len) 320{ 321 register char *cp; 322 register int i; 323 int cnt; 324 325 cp = buffer; 326 while (1) 327 { 328 if (cp - buffer >= max_len) 329 { 330 buffer[max_len - 1] = '\0'; 331 break; 332 } 333 cnt = max_len - (cp - buffer); 334 if (cnt > 8) 335 cnt = 8; 336 read_memory (memaddr + (int) (cp - buffer), cp, cnt); 337 for (i = 0; i < cnt && *cp; i++, cp++) 338 ; /* null body */ 339 340 if (i < cnt && !*cp) 341 break; 342 } 343} 344 345/* Same as target_write_memory, but report an error if can't write. */ 346void 347write_memory (CORE_ADDR memaddr, char *myaddr, int len) 348{ 349 int status; 350 351 status = target_write_memory (memaddr, myaddr, len); 352 if (status != 0) 353 memory_error (status, memaddr); 354} 355 356/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer. */ 357void 358write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value) 359{ 360 char *buf = alloca (len); 361 store_unsigned_integer (buf, len, value); 362 write_memory (addr, buf, len); 363} 364 365/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer. */ 366void 367write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value) 368{ 369 char *buf = alloca (len); 370 store_signed_integer (buf, len, value); 371 write_memory (addr, buf, len); 372} 373 374 375 376#if 0 377/* Enable after 4.12. It is not tested. */ 378 379/* Search code. Targets can just make this their search function, or 380 if the protocol has a less general search function, they can call this 381 in the cases it can't handle. */ 382void 383generic_search (int len, char *data, char *mask, CORE_ADDR startaddr, 384 int increment, CORE_ADDR lorange, CORE_ADDR hirange, 385 CORE_ADDR *addr_found, char *data_found) 386{ 387 int i; 388 CORE_ADDR curaddr = startaddr; 389 390 while (curaddr >= lorange && curaddr < hirange) 391 { 392 read_memory (curaddr, data_found, len); 393 for (i = 0; i < len; ++i) 394 if ((data_found[i] & mask[i]) != data[i]) 395 goto try_again; 396 /* It matches. */ 397 *addr_found = curaddr; 398 return; 399 400 try_again: 401 curaddr += increment; 402 } 403 *addr_found = (CORE_ADDR) 0; 404 return; 405} 406#endif /* 0 */ 407 408/* The current default bfd target. Points to storage allocated for 409 gnutarget_string. */ 410char *gnutarget; 411 412/* Same thing, except it is "auto" not NULL for the default case. */ 413static char *gnutarget_string; 414 415static void set_gnutarget_command (char *, int, struct cmd_list_element *); 416 417static void 418set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c) 419{ 420 if (STREQ (gnutarget_string, "auto")) 421 gnutarget = NULL; 422 else 423 gnutarget = gnutarget_string; 424} 425 426/* Set the gnutarget. */ 427void 428set_gnutarget (char *newtarget) 429{ 430 if (gnutarget_string != NULL) 431 xfree (gnutarget_string); 432 gnutarget_string = savestring (newtarget, strlen (newtarget)); 433 set_gnutarget_command (NULL, 0, NULL); 434} 435 436void 437_initialize_core (void) 438{ 439 struct cmd_list_element *c; 440 c = add_cmd ("core-file", class_files, core_file_command, 441 "Use FILE as core dump for examining memory and registers.\n\ 442No arg means have no core file. This command has been superseded by the\n\ 443`target core' and `detach' commands.", &cmdlist); 444 c->completer = filename_completer; 445 446 c = add_set_cmd ("gnutarget", class_files, var_string_noescape, 447 (char *) &gnutarget_string, 448 "Set the current BFD target.\n\ 449Use `set gnutarget auto' to specify automatic detection.", 450 &setlist); 451 set_cmd_sfunc (c, set_gnutarget_command); 452 add_show_from_set (c, &showlist); 453 454 if (getenv ("GNUTARGET")) 455 set_gnutarget (getenv ("GNUTARGET")); 456 else 457 set_gnutarget ("auto"); 458} 459