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