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) { warning (_("\"%s\": no core file handler recognizes format, using default"), bfd_get_filename (abfd)); } if (yummy == NULL) { yummy = core_file_fns; } return (yummy); }
static void maintenance_info_sections (char *arg, int from_tty) { if (exec_bfd) { printf_filtered (_("Exec file:\n")); printf_filtered (" `%s', ", bfd_get_filename (exec_bfd)); wrap_here (" "); printf_filtered (_("file type %s.\n"), bfd_get_target (exec_bfd)); if (arg && *arg && match_substring (arg, "ALLOBJ")) { struct objfile *ofile; struct obj_section *osect; /* Only this function cares about the 'ALLOBJ' argument; if 'ALLOBJ' is the only argument, discard it rather than passing it down to print_objfile_section_info (which wouldn't know how to handle it). */ if (strcmp (arg, "ALLOBJ") == 0) arg = NULL; ALL_OBJFILES (ofile) { printf_filtered (_(" Object file: %s\n"), bfd_get_filename (ofile->obfd)); ALL_OBJFILE_OSECTIONS (ofile, osect) { print_objfile_section_info (ofile->obfd, osect, arg); } } } else
/* Read inferior memory at ADDR to find the header of a loaded object file and read its in-core symbols out of inferior memory. SIZE, if non-zero, is the known size of the object. TEMPL is a bfd representing the target's format. NAME is the name to use for this symbol file in messages; it can be NULL or a malloc-allocated string which will be attached to the BFD. */ static struct objfile * symbol_file_add_from_memory (struct bfd *templ, CORE_ADDR addr, size_t size, char *name, int from_tty) { struct objfile *objf; struct bfd *nbfd; struct bfd_section *sec; bfd_vma loadbase; struct section_addr_info *sai; unsigned int i; struct cleanup *cleanup; if (bfd_get_flavour (templ) != bfd_target_elf_flavour) error (_("add-symbol-file-from-memory not supported for this target")); nbfd = bfd_elf_bfd_from_remote_memory (templ, addr, size, &loadbase, target_read_memory_bfd); if (nbfd == NULL) error (_("Failed to read a valid object file image from memory.")); gdb_bfd_ref (nbfd); xfree (bfd_get_filename (nbfd)); if (name == NULL) nbfd->filename = xstrdup ("shared object read from target memory"); else nbfd->filename = name; cleanup = make_cleanup_bfd_unref (nbfd); if (!bfd_check_format (nbfd, bfd_object)) error (_("Got object file from memory but can't read symbols: %s."), bfd_errmsg (bfd_get_error ())); sai = alloc_section_addr_info (bfd_count_sections (nbfd)); make_cleanup (xfree, sai); i = 0; for (sec = nbfd->sections; sec != NULL; sec = sec->next) if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0) { sai->other[i].addr = bfd_get_section_vma (nbfd, sec) + loadbase; sai->other[i].name = (char *) bfd_get_section_name (nbfd, sec); sai->other[i].sectindex = sec->index; ++i; } sai->num_sections = i; objf = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd), from_tty ? SYMFILE_VERBOSE : 0, sai, OBJF_SHARED, NULL); add_target_sections_of_objfile (objf); /* This might change our ideas about frames already looked at. */ reinit_frame_cache (); do_cleanups (cleanup); return objf; }
static void nlm_symtab_read (bfd *abfd, CORE_ADDR addr, struct objfile *objfile) { long storage_needed; asymbol *sym; asymbol **symbol_table; long number_of_symbols; long i; struct cleanup *back_to; CORE_ADDR symaddr; enum minimal_symbol_type ms_type; storage_needed = bfd_get_symtab_upper_bound (abfd); if (storage_needed < 0) error ("Can't read symbols from %s: %s", bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ())); if (storage_needed > 0) { symbol_table = (asymbol **) xmalloc (storage_needed); back_to = make_cleanup (xfree, symbol_table); number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); if (number_of_symbols < 0) error ("Can't read symbols from %s: %s", bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ())); for (i = 0; i < number_of_symbols; i++) { sym = symbol_table[i]; if ( /*sym -> flags & BSF_GLOBAL */ 1) { /* Bfd symbols are section relative. */ symaddr = sym->value + sym->section->vma; /* Relocate all non-absolute symbols by base address. */ if (sym->section != &bfd_abs_section) symaddr += addr; /* For non-absolute symbols, use the type of the section they are relative to, to intuit text/data. BFD provides no way of figuring this out for absolute symbols. */ if (sym->section->flags & SEC_CODE) ms_type = mst_text; else if (sym->section->flags & SEC_DATA) ms_type = mst_data; else ms_type = mst_unknown; prim_record_minimal_symbol (sym->name, symaddr, ms_type, objfile); } } do_cleanups (back_to); } }
/* Read inferior memory at ADDR to find the header of a loaded object file and read its in-core symbols out of inferior memory. SIZE, if non-zero, is the known size of the object. TEMPL is a bfd representing the target's format. NAME is the name to use for this symbol file in messages; it can be NULL or a malloc-allocated string which will be attached to the BFD. */ static struct objfile * symbol_file_add_from_memory (struct bfd *templ, CORE_ADDR addr, size_t size, char *name, int from_tty) { struct objfile *objf; struct bfd *nbfd; struct bfd_section *sec; bfd_vma loadbase; symfile_add_flags add_flags = 0; if (bfd_get_flavour (templ) != bfd_target_elf_flavour) error (_("add-symbol-file-from-memory not supported for this target")); nbfd = bfd_elf_bfd_from_remote_memory (templ, addr, size, &loadbase, target_read_memory_bfd); if (nbfd == NULL) error (_("Failed to read a valid object file image from memory.")); /* Manage the new reference for the duration of this function. */ gdb_bfd_ref_ptr nbfd_holder = gdb_bfd_ref_ptr::new_reference (nbfd); xfree (bfd_get_filename (nbfd)); if (name == NULL) nbfd->filename = xstrdup ("shared object read from target memory"); else nbfd->filename = name; if (!bfd_check_format (nbfd, bfd_object)) error (_("Got object file from memory but can't read symbols: %s."), bfd_errmsg (bfd_get_error ())); section_addr_info sai; for (sec = nbfd->sections; sec != NULL; sec = sec->next) if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0) sai.emplace_back (bfd_get_section_vma (nbfd, sec) + loadbase, bfd_get_section_name (nbfd, sec), sec->index); if (from_tty) add_flags |= SYMFILE_VERBOSE; objf = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd), add_flags, &sai, OBJF_SHARED, NULL); add_target_sections_of_objfile (objf); /* This might change our ideas about frames already looked at. */ reinit_frame_cache (); return objf; }
static void do_sections_p1 (struct coff_ofile *head) { asection *section; int idx; struct coff_section *all = (struct coff_section *) (xcalloc (abfd->section_count + 1, sizeof (struct coff_section))); head->nsections = abfd->section_count + 1; head->sections = all; for (idx = 0, section = abfd->sections; section; section = section->next, idx++) { long relsize; int i = section->target_index; arelent **relpp; long relcount; relsize = bfd_get_reloc_upper_bound (abfd, section); if (relsize < 0) bfd_fatal (bfd_get_filename (abfd)); if (relsize == 0) continue; relpp = (arelent **) xmalloc (relsize); relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms); if (relcount < 0) bfd_fatal (bfd_get_filename (abfd)); head->sections[i].name = (char *) (section->name); head->sections[i].code = section->flags & SEC_CODE; head->sections[i].data = section->flags & SEC_DATA; if (strcmp (section->name, ".bss") == 0) head->sections[i].data = 1; head->sections[i].address = section->lma; head->sections[i].size = bfd_get_section_size (section); head->sections[i].number = idx; head->sections[i].nrelocs = section->reloc_count; head->sections[i].relocs = (struct coff_reloc *) (xcalloc (section->reloc_count, sizeof (struct coff_reloc))); head->sections[i].bfd_section = section; } head->sections[0].name = "ABSOLUTE"; head->sections[0].code = 0; head->sections[0].data = 0; head->sections[0].address = 0; head->sections[0].size = 0; head->sections[0].number = 0; }
static void core_close (int quitting) { char *name; if (core_bfd) { int pid = ptid_get_pid (inferior_ptid); inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */ if (pid != 0) exit_inferior_silent (pid); /* Clear out solib state while the bfd is still open. See comments in clear_solib in solib.c. */ clear_solib (); if (core_data) { xfree (core_data->sections); xfree (core_data); core_data = NULL; } name = bfd_get_filename (core_bfd); gdb_bfd_close_or_warn (core_bfd); xfree (name); core_bfd = NULL; } core_vec = NULL; core_gdbarch = NULL; }
bfd_boolean generic_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd) { char *exec; char *core; char *last_slash; if (exec_bfd == NULL || core_bfd == NULL) return TRUE; /* The cast below is to avoid a compiler warning due to the assignment of the const char * returned by bfd_core_file_failing_command to a non-const char *. In this case, the assignement does not lead to breaking the const, as we're only reading the string. */ core = (char *) bfd_core_file_failing_command (core_bfd); if (core == NULL) return TRUE; exec = bfd_get_filename (exec_bfd); if (exec == NULL) return TRUE; last_slash = strrchr (core, '/'); if (last_slash != NULL) core = last_slash + 1; last_slash = strrchr (exec, '/'); if (last_slash != NULL) exec = last_slash + 1; return strcmp (exec, core) == 0; }
static bfd_boolean link_callbacks_undefined_symbol (struct bfd_link_info *link_info, const char *name, bfd *abfd, asection *section, bfd_vma address, bfd_boolean is_fatal) { warning (_("Cannot resolve relocation to \"%s\" " "from compiled module \"%s\" section \"%s\"."), name, bfd_get_filename (abfd), bfd_get_section_name (abfd, section)); return FALSE; }
static void exec_close (int quitting) { int need_symtab_cleanup = 0; struct vmap *vp, *nxt; for (nxt = vmap; nxt != NULL;) { vp = nxt; nxt = vp->nxt; /* if there is an objfile associated with this bfd, free_objfile() will do proper cleanup of objfile *and* bfd. */ if (vp->objfile) { free_objfile (vp->objfile); need_symtab_cleanup = 1; } else if (vp->bfd != exec_bfd) /* FIXME-leak: We should be freeing vp->name too, I think. */ if (!bfd_close (vp->bfd)) warning (_("cannot close \"%s\": %s"), vp->name, bfd_errmsg (bfd_get_error ())); /* FIXME: This routine is #if 0'd in symfile.c. What should we be doing here? Should we just free everything in vp->objfile->symtabs? Should free_objfile do that? FIXME-as-well: free_objfile already free'd vp->name, so it isn't valid here. */ free_named_symtabs (vp->name); xfree (vp); } vmap = NULL; if (exec_bfd) { char *name = bfd_get_filename (exec_bfd); if (!bfd_close (exec_bfd)) warning (_("cannot close \"%s\": %s"), name, bfd_errmsg (bfd_get_error ())); xfree (name); exec_bfd = NULL; exec_bfd_mtime = 0; } if (exec_ops.to_sections) { xfree (exec_ops.to_sections); exec_ops.to_sections = NULL; exec_ops.to_sections_end = NULL; } }
static bfd_boolean link_callbacks_unattached_reloc (struct bfd_link_info *link_info, const char *name, bfd *abfd, asection *section, bfd_vma address) { warning (_("Compiled module \"%s\" section \"%s\": unattached " "relocation: %s\n"), bfd_get_filename (abfd), bfd_get_section_name (abfd, section), name); return FALSE; }
int build_id_verify (bfd *abfd, size_t check_len, const bfd_byte *check) { const struct bfd_build_id *found; int retval = 0; found = build_id_bfd_get (abfd); if (found == NULL) warning (_("File \"%s\" has no build-id, file skipped"), bfd_get_filename (abfd)); else if (found->size != check_len || memcmp (found->data, check, found->size) != 0) warning (_("File \"%s\" has a different build-id, file skipped"), bfd_get_filename (abfd)); else retval = 1; return retval; }
static bfd_boolean link_callbacks_reloc_dangerous (struct bfd_link_info *link_info, const char *message, bfd *abfd, asection *section, bfd_vma address) { warning (_("Compiled module \"%s\" section \"%s\": dangerous " "relocation: %s\n"), bfd_get_filename (abfd), bfd_get_section_name (abfd, section), message); return FALSE; }
static bfd_boolean link_callbacks_warning (struct bfd_link_info *link_info, const char *xwarning, const char *symbol, bfd *abfd, asection *section, bfd_vma address) { warning (_("Compiled module \"%s\" section \"%s\": warning: %s"), bfd_get_filename (abfd), bfd_get_section_name (abfd, section), xwarning); /* Maybe permit running as a module? */ return FALSE; }
void gdb_bfd_stash_filename (struct bfd *abfd) { char *name = bfd_get_filename (abfd); char *data; data = bfd_alloc (abfd, strlen (name) + 1); strcpy (data, name); /* Unwarranted chumminess with BFD. */ abfd->filename = data; }
char * get_exec_file(int err) { if (exec_bfd) return bfd_get_filename(exec_bfd); if (!err) return NULL; error(_("No executable file specified.\n\ Use the \"file\" or \"exec-file\" command.")); return NULL; }
static bfd_boolean link_callbacks_multiple_definition (struct bfd_link_info *link_info, struct bfd_link_hash_entry *h, bfd *nbfd, asection *nsec, bfd_vma nval) { bfd *abfd = link_info->input_bfds; if (link_info->allow_multiple_definition) return TRUE; warning (_("Compiled module \"%s\": multiple symbol definitions: %s"), bfd_get_filename (abfd), h->root.string); return FALSE; }
static void slurp_symtab(bfd * abfd) { long symcount; unsigned int size; if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0) return; symcount = bfd_read_minisymbols(abfd, false, (PTR) & syms, &size); if (symcount == 0) symcount = bfd_read_minisymbols(abfd, true /* dynamic */, (PTR) & syms, &size); if (symcount < 0) bfd_fatal(bfd_get_filename(abfd)); }
core_target::core_target () { m_core_gdbarch = gdbarch_from_bfd (core_bfd); /* Find a suitable core file handler to munch on core_bfd */ m_core_vec = sniff_core_bfd (m_core_gdbarch, core_bfd); /* Find the data section */ if (build_section_table (core_bfd, &m_core_section_table.sections, &m_core_section_table.sections_end)) error (_("\"%s\": Can't find sections: %s"), bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); }
void print_section_info (struct target_ops *t, bfd *abfd) { struct section_table *p; /* FIXME: "016l" is not wide enough when TARGET_ADDR_BIT > 64. */ char *fmt = TARGET_ADDR_BIT <= 32 ? "08l" : "016l"; printf_filtered ("\t`%s', ", bfd_get_filename (abfd)); wrap_here (" "); printf_filtered ("file type %s.\n", bfd_get_target (abfd)); if (abfd == exec_bfd) { printf_filtered ("\tEntry point: "); print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout); printf_filtered ("\n"); } for (p = t->to_sections; p < t->to_sections_end; p++) { printf_filtered ("\t%s", local_hex_string_custom (p->addr, fmt)); printf_filtered (" - %s", local_hex_string_custom (p->endaddr, fmt)); /* FIXME: A format of "08l" is not wide enough for file offsets larger than 4GB. OTOH, making it "016l" isn't desirable either since most output will then be much wider than necessary. It may make sense to test the size of the file and choose the format string accordingly. */ if (info_verbose) printf_filtered (" @ %s", local_hex_string_custom (p->the_bfd_section->filepos, "08l")); printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section)); if (p->bfd != abfd) { printf_filtered (" in %s", bfd_get_filename (p->bfd)); } printf_filtered ("\n"); } }
struct vmap * map_vmap (bfd *abfd, bfd *arch) { struct vmap_and_bfd vmap_bfd; struct vmap *vp, **vpp; vp = (struct vmap *) xmalloc (sizeof (*vp)); memset ((char *) vp, '\0', sizeof (*vp)); vp->nxt = 0; vp->bfd = abfd; vp->name = bfd_get_filename (arch ? arch : abfd); vp->member = arch ? bfd_get_filename (abfd) : ""; vmap_bfd.pbfd = arch; vmap_bfd.pvmap = vp; bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd); /* Find the end of the list and append. */ for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt) ; *vpp = vp; return vp; }
void Archive::Read(const char* filename, Symbol::SymbolIndex_t& symbolIndex) { char *target = 0; bfd *file; file = bfd_openr (filename, target); if (file == 0) { // bfd_nonfatal (filename); // return FALSE; } if (bfd_check_format (file, bfd_archive)) { // display_archive (file); bfd *arfile = 0; std::cout << "file " << bfd_get_filename (file) << std::endl; while(arfile = bfd_openr_next_archived_file (file, arfile)) { const char* objectname = bfd_get_filename (arfile); ObjectFile* o = new ObjectFile(objectname, symbolIndex); o->SetParent(*this); o->Read(arfile); std::cout << "file " << bfd_get_filename (arfile) << std::endl; } if (arfile == NULL) { //if (bfd_get_error () != bfd_error_no_more_archived_files) //bfd_fatal (bfd_get_filename (file)); //break; } } }
void * read_debugging_info (bfd *abfd, asymbol **syms, long symcount, bfd_boolean no_messages) { void *dhandle; bfd_boolean found; dhandle = debug_init (); if (dhandle == NULL) return NULL; if (! read_section_stabs_debugging_info (abfd, syms, symcount, dhandle, &found)) return NULL; if (bfd_get_flavour (abfd) == bfd_target_aout_flavour) { if (! read_symbol_stabs_debugging_info (abfd, syms, symcount, dhandle, &found)) return NULL; } if (bfd_get_flavour (abfd) == bfd_target_ieee_flavour) { if (! read_ieee_debugging_info (abfd, dhandle, &found)) return NULL; } /* Try reading the COFF symbols if we didn't find any stabs in COFF sections. */ if (! found && bfd_get_flavour (abfd) == bfd_target_coff_flavour && symcount > 0) { if (! parse_coff (abfd, syms, symcount, dhandle)) return NULL; found = TRUE; } if (! found) { if (! no_messages) non_fatal (_("%s: no recognized debugging information"), bfd_get_filename (abfd)); return NULL; } return dhandle; }
static void gldelf64ltsmip_vercheck (lang_input_statement_type *s) { const char *soname; struct bfd_link_needed_list *l; if (global_vercheck_failed) return; if (s->the_bfd == NULL || (bfd_get_file_flags (s->the_bfd) & DYNAMIC) == 0) return; soname = bfd_elf_get_dt_soname (s->the_bfd); if (soname == NULL) soname = lbasename (bfd_get_filename (s->the_bfd)); for (l = global_vercheck_needed; l != NULL; l = l->next) { const char *suffix; if (strcmp (soname, l->name) == 0) { /* Probably can't happen, but it's an easy check. */ continue; } if (strchr (l->name, '/') != NULL) continue; suffix = strstr (l->name, ".so."); if (suffix == NULL) continue; suffix += sizeof ".so." - 1; if (strncmp (soname, l->name, suffix - l->name) == 0) { /* Here we know that S is a dynamic object FOO.SO.VER1, and the object we are considering needs a dynamic object FOO.SO.VER2, and VER1 and VER2 are different. This appears to be a version mismatch, so we tell the caller to try a different version of this library. */ global_vercheck_failed = TRUE; return; } } }
void reopen_exec_file(void) { #if 0 /* FIXME */ if (exec_bfd) bfd_reopen(exec_bfd); #else char *filename; int res; struct stat st; long mtime; /* APPLE LOCAL begin gdb_quitting */ /* Do NOT do any of this if we are quitting. */ if (gdb_quitting) return; /* APPLE LOCAL end gdb_quitting */ /* Do NOT do anything if the current target is NOT exec. */ if (exec_bfd == NULL || (strcmp(target_shortname, "exec") != 0)) return; /* If the timestamp of the exec file has changed, reopen it. */ /* APPLE LOCAL comment */ /* The whole world may have changed, so just unset all breakpoints: */ filename = xstrdup(bfd_get_filename(exec_bfd)); make_cleanup(xfree, filename); mtime = bfd_get_mtime(exec_bfd); res = stat(filename, &st); if (res == -1) { warning("stat failed with errno %d (i.e. \"%s\").\n", errno, strerror(errno)); } if (mtime && (mtime != st.st_mtime)) { exec_open(filename, 0); /* APPLE LOCAL begin hooks */ tell_breakpoints_objfile_changed(NULL); /* APPLE LOOCAL cache lookup values for improved performance */ symtab_clear_cached_lookup_values(); tell_objc_msgsend_cacher_objfile_changed(NULL); /* APPLE LOCAL end hooks */ } #endif /* 0 */ }
static void gdbsim_files_info (struct target_ops *target) { char *file = "nothing"; if (exec_bfd) file = bfd_get_filename (exec_bfd); if (sr_get_debug ()) printf_filtered ("gdbsim_files_info: file \"%s\"\n", file); if (exec_bfd) { printf_filtered ("\tAttached to %s running program %s\n", target_shortname, file); sim_info (gdbsim_desc, 0); } }
static void setup_bfd_headers (bfd *ibfd, bfd *obfd) { const char *err; /* Allow the BFD backend to copy any private data it understands from the input section to the output section. */ if (! bfd_copy_private_header_data (ibfd, obfd)) { perror("private header data"); } /* All went well. */ return; fprintf(stderr, "%s: error in %s: %s", bfd_get_filename (ibfd), err, bfd_errmsg (bfd_get_error ())); }
void exec_close (void) { if (exec_bfd) { bfd *abfd = exec_bfd; char *name = bfd_get_filename (abfd); gdb_bfd_close_or_warn (abfd); xfree (name); /* Removing target sections may close the exec_ops target. Clear exec_bfd before doing so to prevent recursion. */ exec_bfd = NULL; exec_bfd_mtime = 0; remove_target_sections (abfd); } }
void showStats() { (void)printf("Filename: %s\n\n", bfd_get_filename(abfd)); (void)printf("File's target: %s\n", bfd_get_target(abfd)); (void)printf("File's endianess: "); if (bfd_little_endian(abfd)) (void)printf("little endian\n"); else (void)printf("big endian\n"); (void)printf("Bits per byte on file's arch: %u bits\n", bfd_arch_bits_per_byte(abfd)); (void)printf("Bits per address on file's arch: %u bits\n\n", bfd_arch_bits_per_address(abfd)); (void)printf("Start address: %p\n", (void *)bfd_get_start_address(abfd)); }
static void core_open (char *filename, int from_tty) { const char *p; int siggy; struct cleanup *old_chain; char *temp; bfd *temp_bfd; int scratch_chan; int flags; volatile struct gdb_exception except; target_preopen (from_tty); if (!filename) { if (core_bfd) error (_("No core file specified. (Use `detach' " "to stop debugging a core file.)")); else error (_("No core file specified.")); } filename = tilde_expand (filename); if (!IS_ABSOLUTE_PATH (filename)) { temp = concat (current_directory, "/", filename, (char *) NULL); xfree (filename); filename = temp; } old_chain = make_cleanup (xfree, filename); flags = O_BINARY | O_LARGEFILE; if (write_files) flags |= O_RDWR; else flags |= O_RDONLY; scratch_chan = open (filename, flags, 0); if (scratch_chan < 0) perror_with_name (filename); temp_bfd = bfd_fopen (filename, gnutarget, write_files ? FOPEN_RUB : FOPEN_RB, scratch_chan); if (temp_bfd == NULL) perror_with_name (filename); if (!bfd_check_format (temp_bfd, bfd_core) && !gdb_check_format (temp_bfd)) { /* Do it after the err msg */ /* FIXME: should be checking for errors from bfd_close (for one thing, on error it does not free all the storage associated with the bfd). */ make_cleanup_bfd_close (temp_bfd); error (_("\"%s\" is not a core dump: %s"), filename, bfd_errmsg (bfd_get_error ())); } /* Looks semi-reasonable. Toss the old core file and work on the new. */ discard_cleanups (old_chain); /* Don't free filename any more */ unpush_target (&core_ops); core_bfd = temp_bfd; old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/); /* FIXME: kettenis/20031023: This is very dangerous. The CORE_GDBARCH that results from this call may very well be different from CURRENT_GDBARCH. However, its methods may only work if it is selected as the current architecture, because they rely on swapped data (see gdbarch.c). We should get rid of that swapped data. */ core_gdbarch = gdbarch_from_bfd (core_bfd); /* Find a suitable core file handler to munch on core_bfd */ core_vec = sniff_core_bfd (core_bfd); validate_files (); core_data = XZALLOC (struct target_section_table); /* Find the data section */ if (build_section_table (core_bfd, &core_data->sections, &core_data->sections_end)) error (_("\"%s\": Can't find sections: %s"), bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); /* If we have no exec file, try to set the architecture from the core file. We don't do this unconditionally since an exec file typically contains more information that helps us determine the architecture than a core file. */ if (!exec_bfd) set_gdbarch_from_file (core_bfd); push_target (&core_ops); discard_cleanups (old_chain); /* Do this before acknowledging the inferior, so if post_create_inferior throws (can happen easilly if you're loading a core file with the wrong exec), we aren't left with threads from the previous inferior. */ init_thread_list (); inferior_ptid = null_ptid; /* Need to flush the register cache (and the frame cache) from a previous debug session. If inferior_ptid ends up the same as the last debug session --- e.g., b foo; run; gcore core1; step; gcore core2; core core1; core core2 --- then there's potential for get_current_regcache to return the cached regcache of the previous session, and the frame cache being stale. */ registers_changed (); /* Build up thread list from BFD sections, and possibly set the current thread to the .reg/NN section matching the .reg section. */ bfd_map_over_sections (core_bfd, add_to_thread_list, bfd_get_section_by_name (core_bfd, ".reg")); if (ptid_equal (inferior_ptid, null_ptid)) { /* Either we found no .reg/NN section, and hence we have a non-threaded core (single-threaded, from gdb's perspective), or for some reason add_to_thread_list couldn't determine which was the "main" thread. The latter case shouldn't usually happen, but we're dealing with input here, which can always be broken in different ways. */ struct thread_info *thread = first_thread_of_process (-1); if (thread == NULL) { inferior_appeared (current_inferior (), CORELOW_PID); inferior_ptid = pid_to_ptid (CORELOW_PID); add_thread_silent (inferior_ptid); } else switch_to_thread (thread->ptid); } post_create_inferior (&core_ops, from_tty); /* Now go through the target stack looking for threads since there may be a thread_stratum target loaded on top of target core by now. The layer above should claim threads found in the BFD sections. */ TRY_CATCH (except, RETURN_MASK_ERROR) { target_find_new_threads (); } if (except.reason < 0) exception_print (gdb_stderr, except); p = bfd_core_file_failing_command (core_bfd); if (p) printf_filtered (_("Core was generated by `%s'.\n"), p); siggy = bfd_core_file_failing_signal (core_bfd); if (siggy > 0) { /* If we don't have a CORE_GDBARCH to work with, assume a native core (map gdb_signal from host signals). If we do have CORE_GDBARCH to work with, but no gdb_signal_from_target implementation for that gdbarch, as a fallback measure, assume the host signal mapping. It'll be correct for native cores, but most likely incorrect for cross-cores. */ enum gdb_signal sig = (core_gdbarch != NULL && gdbarch_gdb_signal_from_target_p (core_gdbarch) ? gdbarch_gdb_signal_from_target (core_gdbarch, siggy) : gdb_signal_from_host (siggy)); printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy, gdb_signal_to_string (sig)); } /* Fetch all registers from core file. */ target_fetch_registers (get_current_regcache (), -1); /* Now, set up the frame cache, and print the top of stack. */ reinit_frame_cache (); print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); }