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