1 /* Core dump and executable file functions below target vector, for GDB. 2 3 Copyright (C) 1986-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "arch-utils.h" 22 #include "gdb_string.h" 23 #include <errno.h> 24 #include <signal.h> 25 #include <fcntl.h> 26 #ifdef HAVE_SYS_FILE_H 27 #include <sys/file.h> /* needed for F_OK and friends */ 28 #endif 29 #include "frame.h" /* required by inferior.h */ 30 #include "inferior.h" 31 #include "symtab.h" 32 #include "command.h" 33 #include "bfd.h" 34 #include "target.h" 35 #include "gdbcore.h" 36 #include "gdbthread.h" 37 #include "regcache.h" 38 #include "regset.h" 39 #include "symfile.h" 40 #include "exec.h" 41 #include "readline/readline.h" 42 #include "gdb_assert.h" 43 #include "exceptions.h" 44 #include "solib.h" 45 #include "filenames.h" 46 #include "progspace.h" 47 #include "objfiles.h" 48 #include "gdb_bfd.h" 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 61 core 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 static 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 104 gdb startup by the _initialize routine in each core file register 105 reader, to register information about each format the reader is 106 prepared to 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. Returns pointer to set that is 130 selected. */ 131 132 static struct core_fns * 133 sniff_core_bfd (bfd *abfd) 134 { 135 struct core_fns *cf; 136 struct core_fns *yummy = NULL; 137 int matches = 0;; 138 139 /* Don't sniff if we have support for register sets in 140 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 error (_("\"%s\": no core file handler recognizes format"), 159 bfd_get_filename (abfd)); 160 161 return (yummy); 162 } 163 164 /* The default is to reject every core file format we see. Either 165 BFD has to recognize it, or we have to provide a function in the 166 core file handler that recognizes it. */ 167 168 int 169 default_check_format (bfd *abfd) 170 { 171 return (0); 172 } 173 174 /* Attempt to recognize core file formats that BFD rejects. */ 175 176 static int 177 gdb_check_format (bfd *abfd) 178 { 179 struct core_fns *cf; 180 181 for (cf = core_file_fns; cf != NULL; cf = cf->next) 182 { 183 if (cf->check_format (abfd)) 184 { 185 return (1); 186 } 187 } 188 return (0); 189 } 190 191 /* Discard all vestiges of any previous core file and mark data and 192 stack spaces as empty. */ 193 194 static void 195 core_close (int quitting) 196 { 197 if (core_bfd) 198 { 199 int pid = ptid_get_pid (inferior_ptid); 200 inferior_ptid = null_ptid; /* Avoid confusion from thread 201 stuff. */ 202 if (pid != 0) 203 exit_inferior_silent (pid); 204 205 /* Clear out solib state while the bfd is still open. See 206 comments in clear_solib in solib.c. */ 207 clear_solib (); 208 209 if (core_data) 210 { 211 xfree (core_data->sections); 212 xfree (core_data); 213 core_data = NULL; 214 } 215 216 gdb_bfd_unref (core_bfd); 217 core_bfd = NULL; 218 } 219 core_vec = NULL; 220 core_gdbarch = NULL; 221 } 222 223 static void 224 core_close_cleanup (void *ignore) 225 { 226 core_close (0/*ignored*/); 227 } 228 229 /* Look for sections whose names start with `.reg/' so that we can 230 extract the list of threads in a core file. */ 231 232 static void 233 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg) 234 { 235 ptid_t ptid; 236 int core_tid; 237 int pid, lwpid; 238 asection *reg_sect = (asection *) reg_sect_arg; 239 int fake_pid_p = 0; 240 struct inferior *inf; 241 242 if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0) 243 return; 244 245 core_tid = atoi (bfd_section_name (abfd, asect) + 5); 246 247 pid = bfd_core_file_pid (core_bfd); 248 if (pid == 0) 249 { 250 fake_pid_p = 1; 251 pid = CORELOW_PID; 252 } 253 254 lwpid = core_tid; 255 256 inf = current_inferior (); 257 if (inf->pid == 0) 258 { 259 inferior_appeared (inf, pid); 260 inf->fake_pid_p = fake_pid_p; 261 } 262 263 ptid = ptid_build (pid, lwpid, 0); 264 265 add_thread (ptid); 266 267 /* Warning, Will Robinson, looking at BFD private data! */ 268 269 if (reg_sect != NULL 270 && asect->filepos == reg_sect->filepos) /* Did we find .reg? */ 271 inferior_ptid = ptid; /* Yes, make it current. */ 272 } 273 274 /* This routine opens and sets up the core file bfd. */ 275 276 static void 277 core_open (char *filename, int from_tty) 278 { 279 const char *p; 280 int siggy; 281 struct cleanup *old_chain; 282 char *temp; 283 bfd *temp_bfd; 284 int scratch_chan; 285 int flags; 286 volatile struct gdb_exception except; 287 288 target_preopen (from_tty); 289 if (!filename) 290 { 291 if (core_bfd) 292 error (_("No core file specified. (Use `detach' " 293 "to stop debugging a core file.)")); 294 else 295 error (_("No core file specified.")); 296 } 297 298 filename = tilde_expand (filename); 299 if (!IS_ABSOLUTE_PATH (filename)) 300 { 301 temp = concat (current_directory, "/", 302 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 = gdb_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 329 thing, on error it does not free all the storage associated 330 with the bfd). */ 331 make_cleanup_bfd_unref (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 337 new. */ 338 339 do_cleanups (old_chain); 340 unpush_target (&core_ops); 341 core_bfd = temp_bfd; 342 old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/); 343 344 core_gdbarch = gdbarch_from_bfd (core_bfd); 345 346 /* Find a suitable core file handler to munch on core_bfd */ 347 core_vec = sniff_core_bfd (core_bfd); 348 349 validate_files (); 350 351 core_data = XZALLOC (struct target_section_table); 352 353 /* Find the data section */ 354 if (build_section_table (core_bfd, 355 &core_data->sections, 356 &core_data->sections_end)) 357 error (_("\"%s\": Can't find sections: %s"), 358 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); 359 360 /* If we have no exec file, try to set the architecture from the 361 core file. We don't do this unconditionally since an exec file 362 typically contains more information that helps us determine the 363 architecture than a core file. */ 364 if (!exec_bfd) 365 set_gdbarch_from_file (core_bfd); 366 367 push_target (&core_ops); 368 discard_cleanups (old_chain); 369 370 /* Do this before acknowledging the inferior, so if 371 post_create_inferior throws (can happen easilly if you're loading 372 a core file with the wrong exec), we aren't left with threads 373 from the previous inferior. */ 374 init_thread_list (); 375 376 inferior_ptid = null_ptid; 377 378 /* Need to flush the register cache (and the frame cache) from a 379 previous debug session. If inferior_ptid ends up the same as the 380 last debug session --- e.g., b foo; run; gcore core1; step; gcore 381 core2; core core1; core core2 --- then there's potential for 382 get_current_regcache to return the cached regcache of the 383 previous session, and the frame cache being stale. */ 384 registers_changed (); 385 386 /* Build up thread list from BFD sections, and possibly set the 387 current thread to the .reg/NN section matching the .reg 388 section. */ 389 bfd_map_over_sections (core_bfd, add_to_thread_list, 390 bfd_get_section_by_name (core_bfd, ".reg")); 391 392 if (ptid_equal (inferior_ptid, null_ptid)) 393 { 394 /* Either we found no .reg/NN section, and hence we have a 395 non-threaded core (single-threaded, from gdb's perspective), 396 or for some reason add_to_thread_list couldn't determine 397 which was the "main" thread. The latter case shouldn't 398 usually happen, but we're dealing with input here, which can 399 always be broken in different ways. */ 400 struct thread_info *thread = first_thread_of_process (-1); 401 402 if (thread == NULL) 403 { 404 inferior_appeared (current_inferior (), CORELOW_PID); 405 inferior_ptid = pid_to_ptid (CORELOW_PID); 406 add_thread_silent (inferior_ptid); 407 } 408 else 409 switch_to_thread (thread->ptid); 410 } 411 412 post_create_inferior (&core_ops, from_tty); 413 414 /* Now go through the target stack looking for threads since there 415 may be a thread_stratum target loaded on top of target core by 416 now. The layer above should claim threads found in the BFD 417 sections. */ 418 TRY_CATCH (except, RETURN_MASK_ERROR) 419 { 420 target_find_new_threads (); 421 } 422 423 if (except.reason < 0) 424 exception_print (gdb_stderr, except); 425 426 p = bfd_core_file_failing_command (core_bfd); 427 if (p) 428 printf_filtered (_("Core was generated by `%s'.\n"), p); 429 430 siggy = bfd_core_file_failing_signal (core_bfd); 431 if (siggy > 0) 432 { 433 /* If we don't have a CORE_GDBARCH to work with, assume a native 434 core (map gdb_signal from host signals). If we do have 435 CORE_GDBARCH to work with, but no gdb_signal_from_target 436 implementation for that gdbarch, as a fallback measure, 437 assume the host signal mapping. It'll be correct for native 438 cores, but most likely incorrect for cross-cores. */ 439 enum gdb_signal sig = (core_gdbarch != NULL 440 && gdbarch_gdb_signal_from_target_p (core_gdbarch) 441 ? gdbarch_gdb_signal_from_target (core_gdbarch, 442 siggy) 443 : gdb_signal_from_host (siggy)); 444 445 printf_filtered (_("Program terminated with signal %d, %s.\n"), 446 siggy, gdb_signal_to_string (sig)); 447 } 448 449 /* Fetch all registers from core file. */ 450 target_fetch_registers (get_current_regcache (), -1); 451 452 /* Now, set up the frame cache, and print the top of stack. */ 453 reinit_frame_cache (); 454 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 455 } 456 457 static void 458 core_detach (struct target_ops *ops, char *args, int from_tty) 459 { 460 if (args) 461 error (_("Too many arguments")); 462 unpush_target (ops); 463 reinit_frame_cache (); 464 if (from_tty) 465 printf_filtered (_("No core file now.\n")); 466 } 467 468 #ifdef DEPRECATED_IBM6000_TARGET 469 470 /* Resize the core memory's section table, by NUM_ADDED. Returns a 471 pointer into the first new slot. This will not be necessary when 472 the rs6000 target is converted to use the standard solib 473 framework. */ 474 475 struct target_section * 476 deprecated_core_resize_section_table (int num_added) 477 { 478 int old_count; 479 480 old_count = resize_section_table (core_data, num_added); 481 return core_data->sections + old_count; 482 } 483 484 #endif 485 486 /* Try to retrieve registers from a section in core_bfd, and supply 487 them to core_vec->core_read_registers, as the register set numbered 488 WHICH. 489 490 If inferior_ptid's lwp member is zero, do the single-threaded 491 thing: look for a section named NAME. If inferior_ptid's lwp 492 member is non-zero, do the multi-threaded thing: look for a section 493 named "NAME/LWP", where LWP is the shortest ASCII decimal 494 representation of inferior_ptid's lwp member. 495 496 HUMAN_NAME is a human-readable name for the kind of registers the 497 NAME section contains, for use in error messages. 498 499 If REQUIRED is non-zero, print an error if the core file doesn't 500 have a section by the appropriate name. Otherwise, just do 501 nothing. */ 502 503 static void 504 get_core_register_section (struct regcache *regcache, 505 const char *name, 506 int which, 507 const char *human_name, 508 int required) 509 { 510 static char *section_name = NULL; 511 struct bfd_section *section; 512 bfd_size_type size; 513 char *contents; 514 515 xfree (section_name); 516 517 if (ptid_get_lwp (inferior_ptid)) 518 section_name = xstrprintf ("%s/%ld", name, 519 ptid_get_lwp (inferior_ptid)); 520 else 521 section_name = xstrdup (name); 522 523 section = bfd_get_section_by_name (core_bfd, section_name); 524 if (! section) 525 { 526 if (required) 527 warning (_("Couldn't find %s registers in core file."), 528 human_name); 529 return; 530 } 531 532 size = bfd_section_size (core_bfd, section); 533 contents = alloca (size); 534 if (! bfd_get_section_contents (core_bfd, section, contents, 535 (file_ptr) 0, size)) 536 { 537 warning (_("Couldn't read %s registers from `%s' section in core file."), 538 human_name, name); 539 return; 540 } 541 542 if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch)) 543 { 544 const struct regset *regset; 545 546 regset = gdbarch_regset_from_core_section (core_gdbarch, 547 name, size); 548 if (regset == NULL) 549 { 550 if (required) 551 warning (_("Couldn't recognize %s registers in core file."), 552 human_name); 553 return; 554 } 555 556 regset->supply_regset (regset, regcache, -1, contents, size); 557 return; 558 } 559 560 gdb_assert (core_vec); 561 core_vec->core_read_registers (regcache, contents, size, which, 562 ((CORE_ADDR) 563 bfd_section_vma (core_bfd, section))); 564 } 565 566 567 /* Get the registers out of a core file. This is the machine- 568 independent part. Fetch_core_registers is the machine-dependent 569 part, typically implemented in the xm-file for each 570 architecture. */ 571 572 /* We just get all the registers, so we don't use regno. */ 573 574 static void 575 get_core_registers (struct target_ops *ops, 576 struct regcache *regcache, int regno) 577 { 578 struct core_regset_section *sect_list; 579 int i; 580 581 if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch)) 582 && (core_vec == NULL || core_vec->core_read_registers == NULL)) 583 { 584 fprintf_filtered (gdb_stderr, 585 "Can't fetch registers from this type of core file\n"); 586 return; 587 } 588 589 sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache)); 590 if (sect_list) 591 while (sect_list->sect_name != NULL) 592 { 593 if (strcmp (sect_list->sect_name, ".reg") == 0) 594 get_core_register_section (regcache, sect_list->sect_name, 595 0, sect_list->human_name, 1); 596 else if (strcmp (sect_list->sect_name, ".reg2") == 0) 597 get_core_register_section (regcache, sect_list->sect_name, 598 2, sect_list->human_name, 0); 599 else 600 get_core_register_section (regcache, sect_list->sect_name, 601 3, sect_list->human_name, 0); 602 603 sect_list++; 604 } 605 606 else 607 { 608 get_core_register_section (regcache, 609 ".reg", 0, "general-purpose", 1); 610 get_core_register_section (regcache, 611 ".reg2", 2, "floating-point", 0); 612 } 613 614 /* Mark all registers not found in the core as unavailable. */ 615 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) 616 if (regcache_register_status (regcache, i) == REG_UNKNOWN) 617 regcache_raw_supply (regcache, i, NULL); 618 } 619 620 static void 621 core_files_info (struct target_ops *t) 622 { 623 print_section_info (core_data, core_bfd); 624 } 625 626 struct spuid_list 627 { 628 gdb_byte *buf; 629 ULONGEST offset; 630 LONGEST len; 631 ULONGEST pos; 632 ULONGEST written; 633 }; 634 635 static void 636 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p) 637 { 638 struct spuid_list *list = list_p; 639 enum bfd_endian byte_order 640 = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE; 641 int fd, pos = 0; 642 643 sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos); 644 if (pos == 0) 645 return; 646 647 if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len) 648 { 649 store_unsigned_integer (list->buf + list->pos - list->offset, 650 4, byte_order, fd); 651 list->written += 4; 652 } 653 list->pos += 4; 654 } 655 656 /* Read siginfo data from the core, if possible. Returns -1 on 657 failure. Otherwise, returns the number of bytes read. ABFD is the 658 core file's BFD; READBUF, OFFSET, and LEN are all as specified by 659 the to_xfer_partial interface. */ 660 661 static LONGEST 662 get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, LONGEST len) 663 { 664 asection *section; 665 char *section_name; 666 const char *name = ".note.linuxcore.siginfo"; 667 668 if (ptid_get_lwp (inferior_ptid)) 669 section_name = xstrprintf ("%s/%ld", name, 670 ptid_get_lwp (inferior_ptid)); 671 else 672 section_name = xstrdup (name); 673 674 section = bfd_get_section_by_name (abfd, section_name); 675 xfree (section_name); 676 if (section == NULL) 677 return -1; 678 679 if (!bfd_get_section_contents (abfd, section, readbuf, offset, len)) 680 return -1; 681 682 return len; 683 } 684 685 static LONGEST 686 core_xfer_partial (struct target_ops *ops, enum target_object object, 687 const char *annex, gdb_byte *readbuf, 688 const gdb_byte *writebuf, ULONGEST offset, 689 LONGEST len) 690 { 691 switch (object) 692 { 693 case TARGET_OBJECT_MEMORY: 694 return section_table_xfer_memory_partial (readbuf, writebuf, 695 offset, len, 696 core_data->sections, 697 core_data->sections_end, 698 NULL); 699 700 case TARGET_OBJECT_AUXV: 701 if (readbuf) 702 { 703 /* When the aux vector is stored in core file, BFD 704 represents this with a fake section called ".auxv". */ 705 706 struct bfd_section *section; 707 bfd_size_type size; 708 709 section = bfd_get_section_by_name (core_bfd, ".auxv"); 710 if (section == NULL) 711 return -1; 712 713 size = bfd_section_size (core_bfd, section); 714 if (offset >= size) 715 return 0; 716 size -= offset; 717 if (size > len) 718 size = len; 719 if (size > 0 720 && !bfd_get_section_contents (core_bfd, section, readbuf, 721 (file_ptr) offset, size)) 722 { 723 warning (_("Couldn't read NT_AUXV note in core file.")); 724 return -1; 725 } 726 727 return size; 728 } 729 return -1; 730 731 case TARGET_OBJECT_WCOOKIE: 732 if (readbuf) 733 { 734 /* When the StackGhost cookie is stored in core file, BFD 735 represents this with a fake section called 736 ".wcookie". */ 737 738 struct bfd_section *section; 739 bfd_size_type size; 740 741 section = bfd_get_section_by_name (core_bfd, ".wcookie"); 742 if (section == NULL) 743 return -1; 744 745 size = bfd_section_size (core_bfd, section); 746 if (offset >= size) 747 return 0; 748 size -= offset; 749 if (size > len) 750 size = len; 751 if (size > 0 752 && !bfd_get_section_contents (core_bfd, section, readbuf, 753 (file_ptr) offset, size)) 754 { 755 warning (_("Couldn't read StackGhost cookie in core file.")); 756 return -1; 757 } 758 759 return size; 760 } 761 return -1; 762 763 case TARGET_OBJECT_LIBRARIES: 764 if (core_gdbarch 765 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch)) 766 { 767 if (writebuf) 768 return -1; 769 return 770 gdbarch_core_xfer_shared_libraries (core_gdbarch, 771 readbuf, offset, len); 772 } 773 /* FALL THROUGH */ 774 775 case TARGET_OBJECT_SPU: 776 if (readbuf && annex) 777 { 778 /* When the SPU contexts are stored in a core file, BFD 779 represents this with a fake section called 780 "SPU/<annex>". */ 781 782 struct bfd_section *section; 783 bfd_size_type size; 784 char sectionstr[100]; 785 786 xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex); 787 788 section = bfd_get_section_by_name (core_bfd, sectionstr); 789 if (section == NULL) 790 return -1; 791 792 size = bfd_section_size (core_bfd, section); 793 if (offset >= size) 794 return 0; 795 size -= offset; 796 if (size > len) 797 size = len; 798 if (size > 0 799 && !bfd_get_section_contents (core_bfd, section, readbuf, 800 (file_ptr) offset, size)) 801 { 802 warning (_("Couldn't read SPU section in core file.")); 803 return -1; 804 } 805 806 return size; 807 } 808 else if (readbuf) 809 { 810 /* NULL annex requests list of all present spuids. */ 811 struct spuid_list list; 812 813 list.buf = readbuf; 814 list.offset = offset; 815 list.len = len; 816 list.pos = 0; 817 list.written = 0; 818 bfd_map_over_sections (core_bfd, add_to_spuid_list, &list); 819 return list.written; 820 } 821 return -1; 822 823 case TARGET_OBJECT_SIGNAL_INFO: 824 if (readbuf) 825 return get_core_siginfo (core_bfd, readbuf, offset, len); 826 return -1; 827 828 default: 829 if (ops->beneath != NULL) 830 return ops->beneath->to_xfer_partial (ops->beneath, object, 831 annex, readbuf, 832 writebuf, offset, len); 833 return -1; 834 } 835 } 836 837 838 /* If mourn is being called in all the right places, this could be say 839 `gdb internal error' (since generic_mourn calls 840 breakpoint_init_inferior). */ 841 842 static int 843 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) 844 { 845 return 0; 846 } 847 848 849 /* Okay, let's be honest: threads gleaned from a core file aren't 850 exactly lively, are they? On the other hand, if we don't claim 851 that each & every one is alive, then we don't get any of them 852 to appear in an "info thread" command, which is quite a useful 853 behaviour. 854 */ 855 static int 856 core_thread_alive (struct target_ops *ops, ptid_t ptid) 857 { 858 return 1; 859 } 860 861 /* Ask the current architecture what it knows about this core file. 862 That will be used, in turn, to pick a better architecture. This 863 wrapper could be avoided if targets got a chance to specialize 864 core_ops. */ 865 866 static const struct target_desc * 867 core_read_description (struct target_ops *target) 868 { 869 if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch)) 870 return gdbarch_core_read_description (core_gdbarch, 871 target, core_bfd); 872 873 return NULL; 874 } 875 876 static char * 877 core_pid_to_str (struct target_ops *ops, ptid_t ptid) 878 { 879 static char buf[64]; 880 struct inferior *inf; 881 int pid; 882 883 /* The preferred way is to have a gdbarch/OS specific 884 implementation. */ 885 if (core_gdbarch 886 && gdbarch_core_pid_to_str_p (core_gdbarch)) 887 return gdbarch_core_pid_to_str (core_gdbarch, ptid); 888 889 /* Otherwise, if we don't have one, we'll just fallback to 890 "process", with normal_pid_to_str. */ 891 892 /* Try the LWPID field first. */ 893 pid = ptid_get_lwp (ptid); 894 if (pid != 0) 895 return normal_pid_to_str (pid_to_ptid (pid)); 896 897 /* Otherwise, this isn't a "threaded" core -- use the PID field, but 898 only if it isn't a fake PID. */ 899 inf = find_inferior_pid (ptid_get_pid (ptid)); 900 if (inf != NULL && !inf->fake_pid_p) 901 return normal_pid_to_str (ptid); 902 903 /* No luck. We simply don't have a valid PID to print. */ 904 xsnprintf (buf, sizeof buf, "<main task>"); 905 return buf; 906 } 907 908 static int 909 core_has_memory (struct target_ops *ops) 910 { 911 return (core_bfd != NULL); 912 } 913 914 static int 915 core_has_stack (struct target_ops *ops) 916 { 917 return (core_bfd != NULL); 918 } 919 920 static int 921 core_has_registers (struct target_ops *ops) 922 { 923 return (core_bfd != NULL); 924 } 925 926 /* Implement the to_info_proc method. */ 927 928 static void 929 core_info_proc (struct target_ops *ops, char *args, enum info_proc_what request) 930 { 931 struct gdbarch *gdbarch = get_current_arch (); 932 933 /* Since this is the core file target, call the 'core_info_proc' 934 method on gdbarch, not 'info_proc'. */ 935 if (gdbarch_core_info_proc_p (gdbarch)) 936 gdbarch_core_info_proc (gdbarch, args, request); 937 } 938 939 /* Fill in core_ops with its defined operations and properties. */ 940 941 static void 942 init_core_ops (void) 943 { 944 core_ops.to_shortname = "core"; 945 core_ops.to_longname = "Local core dump file"; 946 core_ops.to_doc = 947 "Use a core file as a target. Specify the filename of the core file."; 948 core_ops.to_open = core_open; 949 core_ops.to_close = core_close; 950 core_ops.to_attach = find_default_attach; 951 core_ops.to_detach = core_detach; 952 core_ops.to_fetch_registers = get_core_registers; 953 core_ops.to_xfer_partial = core_xfer_partial; 954 core_ops.to_files_info = core_files_info; 955 core_ops.to_insert_breakpoint = ignore; 956 core_ops.to_remove_breakpoint = ignore; 957 core_ops.to_create_inferior = find_default_create_inferior; 958 core_ops.to_thread_alive = core_thread_alive; 959 core_ops.to_read_description = core_read_description; 960 core_ops.to_pid_to_str = core_pid_to_str; 961 core_ops.to_stratum = process_stratum; 962 core_ops.to_has_memory = core_has_memory; 963 core_ops.to_has_stack = core_has_stack; 964 core_ops.to_has_registers = core_has_registers; 965 core_ops.to_info_proc = core_info_proc; 966 core_ops.to_magic = OPS_MAGIC; 967 968 if (core_target) 969 internal_error (__FILE__, __LINE__, 970 _("init_core_ops: core target already exists (\"%s\")."), 971 core_target->to_longname); 972 core_target = &core_ops; 973 } 974 975 void 976 _initialize_corelow (void) 977 { 978 init_core_ops (); 979 980 add_target (&core_ops); 981 } 982