static struct core_fns * sniff_core_bfd (bfd *abfd) { struct core_fns *cf; struct core_fns *yummy = NULL; int matches = 0;; /* Don't sniff if we have support for register sets in CORE_GDBARCH. */ if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch)) return NULL; for (cf = core_file_fns; cf != NULL; cf = cf->next) { if (cf->core_sniffer (cf, abfd)) { yummy = cf; matches++; } } if (matches > 1) { warning (_("\"%s\": ambiguous core format, %d handlers match"), bfd_get_filename (abfd), matches); } else if (matches == 0) error (_("\"%s\": no core file handler recognizes format"), bfd_get_filename (abfd)); return (yummy); }
char * fbsd_make_corefile_notes (bfd *obfd, int *note_size) { const struct regcache *regcache = get_current_regcache (); struct gdbarch *gdbarch = get_regcache_arch (regcache); gregset_t gregs; fpregset_t fpregs; char *note_data = NULL; Elf_Internal_Ehdr *i_ehdrp; const struct regset *regset; size_t size; /* Put a "FreeBSD" label in the ELF header. */ i_ehdrp = elf_elfheader (obfd); i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD; gdb_assert (gdbarch_regset_from_core_section_p (gdbarch)); size = sizeof gregs; regset = gdbarch_regset_from_core_section (gdbarch, ".reg", size); gdb_assert (regset && regset->collect_regset); regset->collect_regset (regset, regcache, -1, &gregs, size); note_data = elfcore_write_prstatus (obfd, note_data, note_size, ptid_get_pid (inferior_ptid), find_stop_signal (), &gregs); size = sizeof fpregs; regset = gdbarch_regset_from_core_section (gdbarch, ".reg2", size); gdb_assert (regset && regset->collect_regset); regset->collect_regset (regset, regcache, -1, &fpregs, size); note_data = elfcore_write_prfpreg (obfd, note_data, note_size, &fpregs, sizeof (fpregs)); if (get_exec_file (0)) { const char *fname = lbasename (get_exec_file (0)); char *psargs = xstrdup (fname); if (get_inferior_args ()) psargs = reconcat (psargs, psargs, " ", get_inferior_args (), (char *) NULL); note_data = elfcore_write_prpsinfo (obfd, note_data, note_size, fname, psargs); } make_cleanup (xfree, note_data); return note_data; }
static void get_core_registers (struct target_ops *ops, struct regcache *regcache, int regno) { struct core_regset_section *sect_list; int i; if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch)) && (core_vec == NULL || core_vec->core_read_registers == NULL)) { fprintf_filtered (gdb_stderr, "Can't fetch registers from this type of core file\n"); return; } sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache)); if (sect_list) while (sect_list->sect_name != NULL) { if (strcmp (sect_list->sect_name, ".reg") == 0) get_core_register_section (regcache, sect_list->sect_name, 0, sect_list->human_name, 1); else if (strcmp (sect_list->sect_name, ".reg2") == 0) get_core_register_section (regcache, sect_list->sect_name, 2, sect_list->human_name, 0); else get_core_register_section (regcache, sect_list->sect_name, 3, sect_list->human_name, 0); sect_list++; } else { get_core_register_section (regcache, ".reg", 0, "general-purpose", 1); get_core_register_section (regcache, ".reg2", 2, "floating-point", 0); } /* Mark all registers not found in the core as unavailable. */ for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) if (regcache_register_status (regcache, i) == REG_UNKNOWN) regcache_raw_supply (regcache, i, NULL); }
static void get_core_register_section (struct regcache *regcache, const char *name, int which, const char *human_name, int required) { static char *section_name = NULL; struct bfd_section *section; bfd_size_type size; char *contents; xfree (section_name); if (ptid_get_lwp (inferior_ptid)) section_name = xstrprintf ("%s/%ld", name, ptid_get_lwp (inferior_ptid)); else section_name = xstrdup (name); section = bfd_get_section_by_name (core_bfd, section_name); if (! section) { if (required) warning (_("Couldn't find %s registers in core file."), human_name); return; } size = bfd_section_size (core_bfd, section); contents = alloca (size); if (! bfd_get_section_contents (core_bfd, section, contents, (file_ptr) 0, size)) { warning (_("Couldn't read %s registers from `%s' section in core file."), human_name, name); return; } if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch)) { const struct regset *regset; regset = gdbarch_regset_from_core_section (core_gdbarch, name, size); if (regset == NULL) { if (required) warning (_("Couldn't recognize %s registers in core file."), human_name); return; } regset->supply_regset (regset, regcache, -1, contents, size); return; } gdb_assert (core_vec); core_vec->core_read_registers (regcache, contents, size, which, ((CORE_ADDR) bfd_section_vma (core_bfd, section))); }