1 /* Core dump and executable file functions below target vector, for GDB. 2 3 Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 4 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 "arch-utils.h" 24 #include "gdb_string.h" 25 #include <errno.h> 26 #include <signal.h> 27 #include <fcntl.h> 28 #ifdef HAVE_SYS_FILE_H 29 #include <sys/file.h> /* needed for F_OK and friends */ 30 #endif 31 #include "frame.h" /* required by inferior.h */ 32 #include "inferior.h" 33 #include "symtab.h" 34 #include "command.h" 35 #include "bfd.h" 36 #include "target.h" 37 #include "gdbcore.h" 38 #include "gdbthread.h" 39 #include "regcache.h" 40 #include "regset.h" 41 #include "symfile.h" 42 #include "exec.h" 43 #include "readline/readline.h" 44 #include "gdb_assert.h" 45 #include "exceptions.h" 46 #include "solib.h" 47 #include "filenames.h" 48 49 50 #ifndef O_LARGEFILE 51 #define O_LARGEFILE 0 52 #endif 53 54 /* List of all available core_fns. On gdb startup, each core file 55 register reader calls deprecated_add_core_fns() to register 56 information on each core format it is prepared to read. */ 57 58 static struct core_fns *core_file_fns = NULL; 59 60 /* The core_fns for a core file handler that is prepared to read the core 61 file currently open on core_bfd. */ 62 63 static struct core_fns *core_vec = NULL; 64 65 /* FIXME: kettenis/20031023: Eventually this variable should 66 disappear. */ 67 68 struct gdbarch *core_gdbarch = NULL; 69 70 /* Per-core data. Currently, only the section table. Note that these 71 target sections are *not* mapped in the current address spaces' set 72 of target sections --- those should come only from pure executable 73 or shared library bfds. The core bfd sections are an 74 implementation detail of the core target, just like ptrace is for 75 unix child targets. */ 76 static struct target_section_table *core_data; 77 78 static void core_files_info (struct target_ops *); 79 80 static struct core_fns *sniff_core_bfd (bfd *); 81 82 static int gdb_check_format (bfd *); 83 84 static void core_open (char *, int); 85 86 static void core_detach (struct target_ops *ops, char *, int); 87 88 static void core_close (int); 89 90 static void core_close_cleanup (void *ignore); 91 92 static void add_to_thread_list (bfd *, asection *, void *); 93 94 static void init_core_ops (void); 95 96 void _initialize_corelow (void); 97 98 struct target_ops core_ops; 99 100 /* An arbitrary identifier for the core inferior. */ 101 #define CORELOW_PID 1 102 103 /* Link a new core_fns into the global core_file_fns list. Called on gdb 104 startup by the _initialize routine in each core file register reader, to 105 register information about each format the the reader is prepared to 106 handle. */ 107 108 void 109 deprecated_add_core_fns (struct core_fns *cf) 110 { 111 cf->next = core_file_fns; 112 core_file_fns = cf; 113 } 114 115 /* The default function that core file handlers can use to examine a 116 core file BFD and decide whether or not to accept the job of 117 reading the core file. */ 118 119 int 120 default_core_sniffer (struct core_fns *our_fns, bfd *abfd) 121 { 122 int result; 123 124 result = (bfd_get_flavour (abfd) == our_fns -> core_flavour); 125 return (result); 126 } 127 128 /* Walk through the list of core functions to find a set that can 129 handle the core file open on ABFD. Default to the first one in the 130 list if nothing matches. Returns pointer to set that is 131 selected. */ 132 133 static struct core_fns * 134 sniff_core_bfd (bfd *abfd) 135 { 136 struct core_fns *cf; 137 struct core_fns *yummy = NULL; 138 int matches = 0;; 139 140 /* Don't sniff if we have support for register sets in CORE_GDBARCH. */ 141 if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch)) 142 return NULL; 143 144 for (cf = core_file_fns; cf != NULL; cf = cf->next) 145 { 146 if (cf->core_sniffer (cf, abfd)) 147 { 148 yummy = cf; 149 matches++; 150 } 151 } 152 if (matches > 1) 153 { 154 warning (_("\"%s\": ambiguous core format, %d handlers match"), 155 bfd_get_filename (abfd), matches); 156 } 157 else if (matches == 0) 158 { 159 warning (_("\"%s\": no core file handler recognizes format, using default"), 160 bfd_get_filename (abfd)); 161 } 162 if (yummy == NULL) 163 { 164 yummy = core_file_fns; 165 } 166 return (yummy); 167 } 168 169 /* The default is to reject every core file format we see. Either 170 BFD has to recognize it, or we have to provide a function in the 171 core file handler that recognizes it. */ 172 173 int 174 default_check_format (bfd *abfd) 175 { 176 return (0); 177 } 178 179 /* Attempt to recognize core file formats that BFD rejects. */ 180 181 static int 182 gdb_check_format (bfd *abfd) 183 { 184 struct core_fns *cf; 185 186 for (cf = core_file_fns; cf != NULL; cf = cf->next) 187 { 188 if (cf->check_format (abfd)) 189 { 190 return (1); 191 } 192 } 193 return (0); 194 } 195 196 /* Discard all vestiges of any previous core file and mark data and stack 197 spaces as empty. */ 198 199 static void 200 core_close (int quitting) 201 { 202 char *name; 203 204 if (core_bfd) 205 { 206 int pid = ptid_get_pid (inferior_ptid); 207 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff */ 208 delete_inferior_silent (pid); 209 210 /* Clear out solib state while the bfd is still open. See 211 comments in clear_solib in solib.c. */ 212 clear_solib (); 213 214 xfree (core_data->sections); 215 xfree (core_data); 216 core_data = NULL; 217 218 name = bfd_get_filename (core_bfd); 219 if (!bfd_close (core_bfd)) 220 warning (_("cannot close \"%s\": %s"), 221 name, bfd_errmsg (bfd_get_error ())); 222 xfree (name); 223 core_bfd = NULL; 224 } 225 core_vec = NULL; 226 core_gdbarch = NULL; 227 } 228 229 static void 230 core_close_cleanup (void *ignore) 231 { 232 core_close (0/*ignored*/); 233 } 234 235 /* Look for sections whose names start with `.reg/' so that we can extract the 236 list of threads in a core file. */ 237 238 static void 239 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg) 240 { 241 ptid_t ptid; 242 int thread_id; 243 asection *reg_sect = (asection *) reg_sect_arg; 244 245 if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0) 246 return; 247 248 thread_id = atoi (bfd_section_name (abfd, asect) + 5); 249 250 if (core_gdbarch 251 && gdbarch_core_reg_section_encodes_pid (core_gdbarch)) 252 { 253 uint32_t merged_pid = thread_id; 254 ptid = ptid_build (merged_pid & 0xffff, 255 merged_pid >> 16, 0); 256 } 257 else 258 ptid = ptid_build (ptid_get_pid (inferior_ptid), thread_id, 0); 259 260 if (ptid_get_lwp (inferior_ptid) == 0) 261 /* The main thread has already been added before getting here, and 262 this is the first time we hear about a thread id. Assume this 263 is the main thread. */ 264 thread_change_ptid (inferior_ptid, ptid); 265 else 266 /* Nope, really a new thread. */ 267 add_thread (ptid); 268 269 /* Warning, Will Robinson, looking at BFD private data! */ 270 271 if (reg_sect != NULL 272 && asect->filepos == reg_sect->filepos) /* Did we find .reg? */ 273 inferior_ptid = ptid; /* Yes, make it current */ 274 } 275 276 /* This routine opens and sets up the core file bfd. */ 277 278 static void 279 core_open (char *filename, int from_tty) 280 { 281 const char *p; 282 int siggy; 283 struct cleanup *old_chain; 284 char *temp; 285 bfd *temp_bfd; 286 int scratch_chan; 287 int flags; 288 int corelow_pid = CORELOW_PID; 289 290 target_preopen (from_tty); 291 if (!filename) 292 { 293 if (core_bfd) 294 error (_("No core file specified. (Use `detach' to stop debugging a core file.)")); 295 else 296 error (_("No core file specified.")); 297 } 298 299 filename = tilde_expand (filename); 300 if (!IS_ABSOLUTE_PATH(filename)) 301 { 302 temp = concat (current_directory, "/", filename, (char *)NULL); 303 xfree (filename); 304 filename = temp; 305 } 306 307 old_chain = make_cleanup (xfree, filename); 308 309 flags = O_BINARY | O_LARGEFILE; 310 if (write_files) 311 flags |= O_RDWR; 312 else 313 flags |= O_RDONLY; 314 scratch_chan = open (filename, flags, 0); 315 if (scratch_chan < 0) 316 perror_with_name (filename); 317 318 temp_bfd = bfd_fopen (filename, gnutarget, 319 write_files ? FOPEN_RUB : FOPEN_RB, 320 scratch_chan); 321 if (temp_bfd == NULL) 322 perror_with_name (filename); 323 324 if (!bfd_check_format (temp_bfd, bfd_core) && 325 !gdb_check_format (temp_bfd)) 326 { 327 /* Do it after the err msg */ 328 /* FIXME: should be checking for errors from bfd_close (for one thing, 329 on error it does not free all the storage associated with the 330 bfd). */ 331 make_cleanup_bfd_close (temp_bfd); 332 error (_("\"%s\" is not a core dump: %s"), 333 filename, bfd_errmsg (bfd_get_error ())); 334 } 335 336 /* Looks semi-reasonable. Toss the old core file and work on the new. */ 337 338 discard_cleanups (old_chain); /* Don't free filename any more */ 339 unpush_target (&core_ops); 340 core_bfd = temp_bfd; 341 old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/); 342 343 /* FIXME: kettenis/20031023: This is very dangerous. The 344 CORE_GDBARCH that results from this call may very well be 345 different from CURRENT_GDBARCH. However, its methods may only 346 work if it is selected as the current architecture, because they 347 rely on swapped data (see gdbarch.c). We should get rid of that 348 swapped data. */ 349 core_gdbarch = gdbarch_from_bfd (core_bfd); 350 351 /* Find a suitable core file handler to munch on core_bfd */ 352 core_vec = sniff_core_bfd (core_bfd); 353 354 validate_files (); 355 356 core_data = XZALLOC (struct target_section_table); 357 358 /* Find the data section */ 359 if (build_section_table (core_bfd, 360 &core_data->sections, &core_data->sections_end)) 361 error (_("\"%s\": Can't find sections: %s"), 362 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); 363 364 /* If we have no exec file, try to set the architecture from the 365 core file. We don't do this unconditionally since an exec file 366 typically contains more information that helps us determine the 367 architecture than a core file. */ 368 if (!exec_bfd) 369 set_gdbarch_from_file (core_bfd); 370 371 push_target (&core_ops); 372 discard_cleanups (old_chain); 373 374 add_inferior_silent (corelow_pid); 375 376 /* Do this before acknowledging the inferior, so if 377 post_create_inferior throws (can happen easilly if you're loading 378 a core file with the wrong exec), we aren't left with threads 379 from the previous inferior. */ 380 init_thread_list (); 381 382 /* Set INFERIOR_PTID early, so an upper layer can rely on it being 383 set while in the target_find_new_threads call below. */ 384 inferior_ptid = pid_to_ptid (corelow_pid); 385 386 /* Assume ST --- Add a main task. We'll later detect when we go 387 from ST to MT. */ 388 add_thread_silent (inferior_ptid); 389 390 /* Need to flush the register cache (and the frame cache) from a 391 previous debug session. If inferior_ptid ends up the same as the 392 last debug session --- e.g., b foo; run; gcore core1; step; gcore 393 core2; core core1; core core2 --- then there's potential for 394 get_current_regcache to return the cached regcache of the 395 previous session, and the frame cache being stale. */ 396 registers_changed (); 397 398 /* Build up thread list from BFD sections, and possibly set the 399 current thread to the .reg/NN section matching the .reg 400 section. */ 401 bfd_map_over_sections (core_bfd, add_to_thread_list, 402 bfd_get_section_by_name (core_bfd, ".reg")); 403 404 post_create_inferior (&core_ops, from_tty); 405 406 /* Now go through the target stack looking for threads since there 407 may be a thread_stratum target loaded on top of target core by 408 now. The layer above should claim threads found in the BFD 409 sections. */ 410 target_find_new_threads (); 411 412 p = bfd_core_file_failing_command (core_bfd); 413 if (p) 414 printf_filtered (_("Core was generated by `%s'.\n"), p); 415 416 siggy = bfd_core_file_failing_signal (core_bfd); 417 if (siggy > 0) 418 /* NOTE: target_signal_from_host() converts a target signal value 419 into gdb's internal signal value. Unfortunately gdb's internal 420 value is called ``target_signal'' and this function got the 421 name ..._from_host(). */ 422 printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy, 423 target_signal_to_string ( 424 (core_gdbarch != NULL) ? 425 gdbarch_target_signal_from_host (core_gdbarch, siggy) 426 : siggy)); 427 428 /* Fetch all registers from core file. */ 429 target_fetch_registers (get_current_regcache (), -1); 430 431 /* Now, set up the frame cache, and print the top of stack. */ 432 reinit_frame_cache (); 433 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 434 } 435 436 static void 437 core_detach (struct target_ops *ops, char *args, int from_tty) 438 { 439 if (args) 440 error (_("Too many arguments")); 441 unpush_target (ops); 442 reinit_frame_cache (); 443 if (from_tty) 444 printf_filtered (_("No core file now.\n")); 445 } 446 447 #ifdef DEPRECATED_IBM6000_TARGET 448 449 /* Resize the core memory's section table, by NUM_ADDED. Returns a 450 pointer into the first new slot. This will not be necessary when 451 the rs6000 target is converted to use the standard solib 452 framework. */ 453 454 struct target_section * 455 deprecated_core_resize_section_table (int num_added) 456 { 457 int old_count; 458 459 old_count = resize_section_table (core_data, num_added); 460 return core_data->sections + old_count; 461 } 462 463 #endif 464 465 /* Try to retrieve registers from a section in core_bfd, and supply 466 them to core_vec->core_read_registers, as the register set numbered 467 WHICH. 468 469 If inferior_ptid's lwp member is zero, do the single-threaded 470 thing: look for a section named NAME. If inferior_ptid's lwp 471 member is non-zero, do the multi-threaded thing: look for a section 472 named "NAME/LWP", where LWP is the shortest ASCII decimal 473 representation of inferior_ptid's lwp member. 474 475 HUMAN_NAME is a human-readable name for the kind of registers the 476 NAME section contains, for use in error messages. 477 478 If REQUIRED is non-zero, print an error if the core file doesn't 479 have a section by the appropriate name. Otherwise, just do nothing. */ 480 481 static void 482 get_core_register_section (struct regcache *regcache, 483 char *name, 484 int which, 485 char *human_name, 486 int required) 487 { 488 static char *section_name = NULL; 489 struct bfd_section *section; 490 bfd_size_type size; 491 char *contents; 492 493 xfree (section_name); 494 495 if (core_gdbarch 496 && gdbarch_core_reg_section_encodes_pid (core_gdbarch)) 497 { 498 uint32_t merged_pid; 499 500 merged_pid = ptid_get_lwp (inferior_ptid); 501 merged_pid = merged_pid << 16 | ptid_get_pid (inferior_ptid); 502 503 section_name = xstrprintf ("%s/%s", name, plongest (merged_pid)); 504 } 505 else if (ptid_get_lwp (inferior_ptid)) 506 section_name = xstrprintf ("%s/%ld", name, ptid_get_lwp (inferior_ptid)); 507 else 508 section_name = xstrdup (name); 509 510 section = bfd_get_section_by_name (core_bfd, section_name); 511 if (! section) 512 { 513 if (required) 514 warning (_("Couldn't find %s registers in core file."), human_name); 515 return; 516 } 517 518 size = bfd_section_size (core_bfd, section); 519 contents = alloca (size); 520 if (! bfd_get_section_contents (core_bfd, section, contents, 521 (file_ptr) 0, size)) 522 { 523 warning (_("Couldn't read %s registers from `%s' section in core file."), 524 human_name, name); 525 return; 526 } 527 528 if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch)) 529 { 530 const struct regset *regset; 531 532 regset = gdbarch_regset_from_core_section (core_gdbarch, name, size); 533 if (regset == NULL) 534 { 535 if (required) 536 warning (_("Couldn't recognize %s registers in core file."), 537 human_name); 538 return; 539 } 540 541 regset->supply_regset (regset, regcache, -1, contents, size); 542 return; 543 } 544 545 gdb_assert (core_vec); 546 core_vec->core_read_registers (regcache, contents, size, which, 547 ((CORE_ADDR) 548 bfd_section_vma (core_bfd, section))); 549 } 550 551 552 /* Get the registers out of a core file. This is the machine- 553 independent part. Fetch_core_registers is the machine-dependent 554 part, typically implemented in the xm-file for each architecture. */ 555 556 /* We just get all the registers, so we don't use regno. */ 557 558 static void 559 get_core_registers (struct target_ops *ops, 560 struct regcache *regcache, int regno) 561 { 562 int i; 563 564 if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch)) 565 && (core_vec == NULL || core_vec->core_read_registers == NULL)) 566 { 567 fprintf_filtered (gdb_stderr, 568 "Can't fetch registers from this type of core file\n"); 569 return; 570 } 571 572 get_core_register_section (regcache, 573 ".reg", 0, "general-purpose", 1); 574 get_core_register_section (regcache, 575 ".reg2", 2, "floating-point", 0); 576 get_core_register_section (regcache, 577 ".reg-xfp", 3, "extended floating-point", 0); 578 get_core_register_section (regcache, 579 ".reg-ppc-vmx", 3, "ppc Altivec", 0); 580 get_core_register_section (regcache, 581 ".reg-ppc-vsx", 4, "POWER7 VSX", 0); 582 583 /* Supply dummy value for all registers not found in the core. */ 584 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 585 if (!regcache_valid_p (regcache, i)) 586 regcache_raw_supply (regcache, i, NULL); 587 } 588 589 static void 590 core_files_info (struct target_ops *t) 591 { 592 print_section_info (core_data, core_bfd); 593 } 594 595 struct spuid_list 596 { 597 gdb_byte *buf; 598 ULONGEST offset; 599 LONGEST len; 600 ULONGEST pos; 601 ULONGEST written; 602 }; 603 604 static void 605 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p) 606 { 607 struct spuid_list *list = list_p; 608 enum bfd_endian byte_order 609 = bfd_big_endian (abfd)? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE; 610 int fd, pos = 0; 611 612 sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos); 613 if (pos == 0) 614 return; 615 616 if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len) 617 { 618 store_unsigned_integer (list->buf + list->pos - list->offset, 619 4, byte_order, fd); 620 list->written += 4; 621 } 622 list->pos += 4; 623 } 624 625 static LONGEST 626 core_xfer_partial (struct target_ops *ops, enum target_object object, 627 const char *annex, gdb_byte *readbuf, 628 const gdb_byte *writebuf, ULONGEST offset, LONGEST len) 629 { 630 switch (object) 631 { 632 case TARGET_OBJECT_MEMORY: 633 return section_table_xfer_memory_partial (readbuf, writebuf, 634 offset, len, 635 core_data->sections, 636 core_data->sections_end, 637 NULL); 638 639 case TARGET_OBJECT_AUXV: 640 if (readbuf) 641 { 642 /* When the aux vector is stored in core file, BFD 643 represents this with a fake section called ".auxv". */ 644 645 struct bfd_section *section; 646 bfd_size_type size; 647 char *contents; 648 649 section = bfd_get_section_by_name (core_bfd, ".auxv"); 650 if (section == NULL) 651 return -1; 652 653 size = bfd_section_size (core_bfd, section); 654 if (offset >= size) 655 return 0; 656 size -= offset; 657 if (size > len) 658 size = len; 659 if (size > 0 660 && !bfd_get_section_contents (core_bfd, section, readbuf, 661 (file_ptr) offset, size)) 662 { 663 warning (_("Couldn't read NT_AUXV note in core file.")); 664 return -1; 665 } 666 667 return size; 668 } 669 return -1; 670 671 case TARGET_OBJECT_WCOOKIE: 672 if (readbuf) 673 { 674 /* When the StackGhost cookie is stored in core file, BFD 675 represents this with a fake section called ".wcookie". */ 676 677 struct bfd_section *section; 678 bfd_size_type size; 679 char *contents; 680 681 section = bfd_get_section_by_name (core_bfd, ".wcookie"); 682 if (section == NULL) 683 return -1; 684 685 size = bfd_section_size (core_bfd, section); 686 if (offset >= size) 687 return 0; 688 size -= offset; 689 if (size > len) 690 size = len; 691 if (size > 0 692 && !bfd_get_section_contents (core_bfd, section, readbuf, 693 (file_ptr) offset, size)) 694 { 695 warning (_("Couldn't read StackGhost cookie in core file.")); 696 return -1; 697 } 698 699 return size; 700 } 701 return -1; 702 703 case TARGET_OBJECT_LIBRARIES: 704 if (core_gdbarch 705 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch)) 706 { 707 if (writebuf) 708 return -1; 709 return 710 gdbarch_core_xfer_shared_libraries (core_gdbarch, 711 readbuf, offset, len); 712 } 713 /* FALL THROUGH */ 714 715 case TARGET_OBJECT_SPU: 716 if (readbuf && annex) 717 { 718 /* When the SPU contexts are stored in a core file, BFD 719 represents this with a fake section called "SPU/<annex>". */ 720 721 struct bfd_section *section; 722 bfd_size_type size; 723 char *contents; 724 725 char sectionstr[100]; 726 xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex); 727 728 section = bfd_get_section_by_name (core_bfd, sectionstr); 729 if (section == NULL) 730 return -1; 731 732 size = bfd_section_size (core_bfd, section); 733 if (offset >= size) 734 return 0; 735 size -= offset; 736 if (size > len) 737 size = len; 738 if (size > 0 739 && !bfd_get_section_contents (core_bfd, section, readbuf, 740 (file_ptr) offset, size)) 741 { 742 warning (_("Couldn't read SPU section in core file.")); 743 return -1; 744 } 745 746 return size; 747 } 748 else if (readbuf) 749 { 750 /* NULL annex requests list of all present spuids. */ 751 struct spuid_list list; 752 list.buf = readbuf; 753 list.offset = offset; 754 list.len = len; 755 list.pos = 0; 756 list.written = 0; 757 bfd_map_over_sections (core_bfd, add_to_spuid_list, &list); 758 return list.written; 759 } 760 return -1; 761 762 default: 763 if (ops->beneath != NULL) 764 return ops->beneath->to_xfer_partial (ops->beneath, object, annex, 765 readbuf, writebuf, offset, len); 766 return -1; 767 } 768 } 769 770 771 /* If mourn is being called in all the right places, this could be say 772 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */ 773 774 static int 775 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) 776 { 777 return 0; 778 } 779 780 781 /* Okay, let's be honest: threads gleaned from a core file aren't 782 exactly lively, are they? On the other hand, if we don't claim 783 that each & every one is alive, then we don't get any of them 784 to appear in an "info thread" command, which is quite a useful 785 behaviour. 786 */ 787 static int 788 core_thread_alive (struct target_ops *ops, ptid_t ptid) 789 { 790 return 1; 791 } 792 793 /* Ask the current architecture what it knows about this core file. 794 That will be used, in turn, to pick a better architecture. This 795 wrapper could be avoided if targets got a chance to specialize 796 core_ops. */ 797 798 static const struct target_desc * 799 core_read_description (struct target_ops *target) 800 { 801 if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch)) 802 return gdbarch_core_read_description (core_gdbarch, target, core_bfd); 803 804 return NULL; 805 } 806 807 static char * 808 core_pid_to_str (struct target_ops *ops, ptid_t ptid) 809 { 810 static char buf[64]; 811 812 if (core_gdbarch 813 && gdbarch_core_pid_to_str_p (core_gdbarch)) 814 { 815 char *ret = gdbarch_core_pid_to_str (core_gdbarch, ptid); 816 if (ret != NULL) 817 return ret; 818 } 819 820 if (ptid_get_lwp (ptid) == 0) 821 xsnprintf (buf, sizeof buf, "<main task>"); 822 else 823 xsnprintf (buf, sizeof buf, "Thread %ld", ptid_get_lwp (ptid)); 824 825 return buf; 826 } 827 828 static int 829 core_has_memory (struct target_ops *ops) 830 { 831 return (core_bfd != NULL); 832 } 833 834 static int 835 core_has_stack (struct target_ops *ops) 836 { 837 return (core_bfd != NULL); 838 } 839 840 static int 841 core_has_registers (struct target_ops *ops) 842 { 843 return (core_bfd != NULL); 844 } 845 846 /* Fill in core_ops with its defined operations and properties. */ 847 848 static void 849 init_core_ops (void) 850 { 851 core_ops.to_shortname = "core"; 852 core_ops.to_longname = "Local core dump file"; 853 core_ops.to_doc = 854 "Use a core file as a target. Specify the filename of the core file."; 855 core_ops.to_open = core_open; 856 core_ops.to_close = core_close; 857 core_ops.to_attach = find_default_attach; 858 core_ops.to_detach = core_detach; 859 core_ops.to_fetch_registers = get_core_registers; 860 core_ops.to_xfer_partial = core_xfer_partial; 861 core_ops.to_files_info = core_files_info; 862 core_ops.to_insert_breakpoint = ignore; 863 core_ops.to_remove_breakpoint = ignore; 864 core_ops.to_create_inferior = find_default_create_inferior; 865 core_ops.to_thread_alive = core_thread_alive; 866 core_ops.to_read_description = core_read_description; 867 core_ops.to_pid_to_str = core_pid_to_str; 868 core_ops.to_stratum = core_stratum; 869 core_ops.to_has_memory = core_has_memory; 870 core_ops.to_has_stack = core_has_stack; 871 core_ops.to_has_registers = core_has_registers; 872 core_ops.to_magic = OPS_MAGIC; 873 } 874 875 void 876 _initialize_corelow (void) 877 { 878 init_core_ops (); 879 880 add_target (&core_ops); 881 } 882