SIM_RC sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty) { TRACE(trace_gdb, ("sim_load(prog=%s, from_tty=%d) called\n", prog, from_tty)); ASSERT(prog != NULL); /* create the simulator */ TRACE(trace_gdb, ("sim_load() - first time, create the simulator\n")); simulator = psim_create(prog, root_device); /* bring in all the data section */ psim_init(simulator); /* get the start address */ if (abfd == NULL) { abfd = bfd_openr (prog, 0); if (abfd == NULL) error ("psim: can't open \"%s\": %s\n", prog, bfd_errmsg (bfd_get_error ())); if (!bfd_check_format (abfd, bfd_object)) { const char *errmsg = bfd_errmsg (bfd_get_error ()); bfd_close (abfd); error ("psim: \"%s\" is not an object file: %s\n", prog, errmsg); } bfd_close (abfd); } return SIM_RC_OK; }
static bfd * bfd_openw_with_cleanup(const char *filename, const char *target, const char *mode) { bfd *obfd; if (*mode == 'w') /* Write: create new file */ { obfd = bfd_openw(filename, target); if (obfd == NULL) error(_("Failed to open %s: %s."), filename, bfd_errmsg(bfd_get_error())); make_cleanup_bfd_close(obfd); if (!bfd_set_format(obfd, bfd_object)) error(_("bfd_openw_with_cleanup: %s."), bfd_errmsg(bfd_get_error())); } else if (*mode == 'a') /* Append to existing file */ { /* FIXME: does NOT work... */ error(_("bfd_openw does not work with append.")); } else error(_("bfd_openw_with_cleanup: unknown mode %s."), mode); return obfd; }
static LdInfo * rs6000_core_ldinfo (bfd *abfd) { struct bfd_section *ldinfo_sec; int ldinfo_size; gdb_byte *ldinfo_buf; struct cleanup *cleanup; ldinfo_sec = bfd_get_section_by_name (abfd, ".ldinfo"); if (ldinfo_sec == NULL) error (_("cannot find .ldinfo section from core file: %s\n"), bfd_errmsg (bfd_get_error ())); ldinfo_size = bfd_get_section_size (ldinfo_sec); ldinfo_buf = xmalloc (ldinfo_size); cleanup = make_cleanup (xfree, ldinfo_buf); if (! bfd_get_section_contents (abfd, ldinfo_sec, ldinfo_buf, 0, ldinfo_size)) error (_("unable to read .ldinfo section from core file: %s\n"), bfd_errmsg (bfd_get_error ())); discard_cleanups (cleanup); return (LdInfo *) ldinfo_buf; }
void bfd_perror (const char *message) { fflush (stdout); if (message == NULL || *message == '\0') fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); else fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); fflush (stderr); }
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 int init_bfd_ctx (struct bfd_ctx *bc, const char * procname, struct output_buffer *ob) { bfd *b; void *symbol_table; unsigned dummy = 0; char **matching = NULL; bc->handle = NULL; bc->symbol = NULL; b = bfd_openr(procname, 0); if (!b) { output_print(ob, "Failed to open bfd from (%s)\n", procname); return 1; } if (bfd_check_format(b, bfd_archive)) { output_print(ob, "Cannot get addresses from archive (%s)\n", b->filename); bfd_close(b); return -1; } if (!bfd_check_format_matches(b, bfd_object, &matching)) { const char *errmsg = bfd_errmsg(bfd_get_error()); output_print(ob, "%s (%s)\n", errmsg, b->filename); if (bfd_get_error() == bfd_error_file_ambiguously_recognized) { list_matching_formats(ob, b->filename, matching); free(matching); } bfd_close(b); return -1; } if ((bfd_get_file_flags(b) & HAS_SYMS) == 0) { const char *errmsg = bfd_errmsg(bfd_get_error()); output_print(ob, "Failed to get file flags from (%s) %s\n", b->filename, errmsg); bfd_close(b); return 1; } if (bfd_read_minisymbols(b, FALSE, &symbol_table, &dummy) == 0) { if (bfd_read_minisymbols(b, TRUE, &symbol_table, &dummy) < 0) { const char *errmsg = bfd_errmsg(bfd_get_error()); output_print(ob, "Failed to read symbols from (%s): %s\n", b->filename, errmsg); free(symbol_table); bfd_close(b); return 1; } } bc->handle = b; bc->symbol = symbol_table; return 0; }
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); } }
int create_inferior (char *program, char **argv) { bfd *abfd; int pid = 0; char **new_argv; int nargs; abfd = bfd_openr (program, 0); if (!abfd) { fprintf (stderr, "gdbserver: cannot open %s: %s\n", program, bfd_errmsg (bfd_get_error ())); exit (1); } if (!bfd_check_format (abfd, bfd_object)) { fprintf (stderr, "gdbserver: unknown load format for %s: %s\n", program, bfd_errmsg (bfd_get_error ())); exit (1); } /* Add "-E big" or "-E little" to the argument list depending on the endianness of the program to be loaded. */ for (nargs = 0; argv[nargs] != NULL; nargs++) /* count the args */ ; new_argv = alloca (sizeof (char *) * (nargs + 3)); /* allocate new args */ for (nargs = 0; argv[nargs] != NULL; nargs++) /* copy old to new */ new_argv[nargs] = argv[nargs]; new_argv[nargs] = "-E"; new_argv[nargs + 1] = bfd_big_endian (abfd) ? "big" : "little"; new_argv[nargs + 2] = NULL; argv = new_argv; /* Create an instance of the simulator. */ default_callback.init (&default_callback); gdbsim_desc = sim_open (SIM_OPEN_STANDALONE, &default_callback, abfd, argv); if (gdbsim_desc == 0) exit (1); /* Load the program into the simulator. */ if (abfd) if (sim_load (gdbsim_desc, program, NULL, 0) == SIM_RC_FAIL) mygeneric_load (abfd); /* Create an inferior process in the simulator. This initializes SP. */ sim_create_inferior (gdbsim_desc, abfd, argv, /* env */ NULL); sim_resume (gdbsim_desc, 1, 0); /* execute one instr */ return pid; }
void bfd_perror (const char *message) { if (bfd_get_error () == bfd_error_system_call) /* Must be a system error then. */ perror ((char *) message); else { if (message == NULL || *message == '\0') fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); else fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); } }
static void mipscoff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) { bfd *abfd = objfile->obfd; minimal_symbol_reader reader (objfile); /* Now that the executable file is positioned at symbol table, process it and define symbols accordingly. */ if (!((*ecoff_backend (abfd)->debug_swap.read_debug_info) (abfd, (asection *) NULL, &ecoff_data (abfd)->debug_info))) error (_("Error reading symbol table: %s"), bfd_errmsg (bfd_get_error ())); mdebug_build_psymtabs (reader, objfile, &ecoff_backend (abfd)->debug_swap, &ecoff_data (abfd)->debug_info); /* Add alpha coff dynamic symbols. */ read_alphacoff_dynamic_symtab (reader, objfile->section_offsets, objfile); /* Install any minimal symbols that have been collected as the current minimal symbols for this objfile. */ reader.install (); }
static segT make_debug_seg (segT cseg, char *name, int sflags) { segT save_seg = now_seg; int save_subseg = now_subseg; segT r; flagword flags; r = subseg_new (name, 0); /* Check if code segment is marked as linked once. */ if (!cseg) flags = 0; else flags = bfd_get_section_flags (stdoutput, cseg) & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE | SEC_LINK_DUPLICATES_SAME_CONTENTS); /* Add standard section flags. */ flags |= sflags; /* Apply possibly linked once flags to new generated segment, too. */ if (!bfd_set_section_flags (stdoutput, r, flags)) as_bad (_("bfd_set_section_flags: %s"), bfd_errmsg (bfd_get_error ())); /* Restore to previous segment. */ if (save_seg != NULL) subseg_set (save_seg, save_subseg); return r; }
void objdump(const char *path) { bfd_init(); bfd *abfd = bfd_openr(path, NULL); if (abfd == NULL) errx(1, bfd_errmsg(bfd_get_error())); if (!bfd_check_format(abfd, bfd_object)) { bfd_close_all_done(abfd); errx(1, "File is not a valid object file."); } printf("%s: file format %s\n", path, bfd_get_target(abfd)); printf("architecture: %s, flags: 0x%08x\n", bfd_printable_arch_mach(bfd_get_arch(abfd), bfd_get_mach(abfd)), abfd->flags); printf("start address 0x%016lx", bfd_get_start_address(abfd)); printf("\n"); printf("Sections:\n"); printf("Idx Name Size VMA LMA File off Algn\n"); printf(" Flags Content\n"); object_stats stats = { FALSE, FALSE }; bfd_map_over_sections(abfd, (void (*)(bfd *, asection *, void *))print_section, &stats); if (stats.contains_hello && stats.contains_world) printf("\nThis file might be a hello world program!\n"); bfd_close(abfd); }
static bfd * darwin_bfd_open (char *pathname) { char *found_pathname; int found_file; bfd *abfd; bfd *res; /* Search for shared library file. */ found_pathname = solib_find (pathname, &found_file); if (found_pathname == NULL) perror_with_name (pathname); /* Open bfd for shared library. */ abfd = solib_bfd_fopen (found_pathname, found_file); res = gdb_bfd_mach_o_fat_extract (abfd, bfd_object, gdbarch_bfd_arch_info (target_gdbarch ())); if (!res) { make_cleanup_bfd_unref (abfd); error (_("`%s': not a shared-library: %s"), bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ())); } /* The current filename for fat-binary BFDs is a name generated by BFD, usually a string containing the name of the architecture. Reset its value to the actual filename. */ xfree (bfd_get_filename (res)); res->filename = xstrdup (pathname); gdb_bfd_unref (abfd); return res; }
const char * bfd_errmsg (bfd_error_type error_tag) { #ifndef errno extern int errno; #endif if (error_tag == bfd_error_on_input) { char *buf; const char *msg = bfd_errmsg (input_error); if (asprintf (&buf, _(bfd_errmsgs [error_tag]), input_bfd->filename, msg) != -1) return buf; /* Ick, what to do on out of memory? */ return msg; } if (error_tag == bfd_error_system_call) return xstrerror (errno); if (error_tag > bfd_error_invalid_error_code) error_tag = bfd_error_invalid_error_code; /* sanity check */ return _(bfd_errmsgs [error_tag]); }
/* Read inferior memory at ADDR to find the header of a loaded object file and read its in-core symbols out of inferior memory. 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, 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, &loadbase, target_read_memory_bfd); if (nbfd == NULL) error (_("Failed to read a valid object file image from memory.")); gdb_bfd_ref (nbfd); if (name == NULL) nbfd->filename = "shared object read from target memory"; else { nbfd->filename = name; gdb_bfd_stash_filename (nbfd); xfree (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); /* This might change our ideas about frames already looked at. */ reinit_frame_cache (); do_cleanups (cleanup); return objf; }
static void write_gcore_file_1 (bfd *obfd) { struct cleanup *cleanup; void *note_data = NULL; int note_size = 0; asection *note_sec = NULL; /* An external target method must build the notes section. */ /* FIXME: uweigand/2011-10-06: All architectures that support core file generation should be converted to gdbarch_make_corefile_notes; at that point, the target vector method can be removed. */ if (!gdbarch_make_corefile_notes_p (target_gdbarch ())) note_data = target_make_corefile_notes (obfd, ¬e_size); else note_data = gdbarch_make_corefile_notes (target_gdbarch (), obfd, ¬e_size); cleanup = make_cleanup (xfree, note_data); if (note_data == NULL || note_size == 0) error (_("Target does not support core file generation.")); /* Create the note section. */ note_sec = bfd_make_section_anyway_with_flags (obfd, "note0", SEC_HAS_CONTENTS | SEC_READONLY | SEC_ALLOC); if (note_sec == NULL) error (_("Failed to create 'note' section for corefile: %s"), bfd_errmsg (bfd_get_error ())); bfd_set_section_vma (obfd, note_sec, 0); bfd_set_section_alignment (obfd, note_sec, 0); bfd_set_section_size (obfd, note_sec, note_size); /* Now create the memory/load sections. */ if (gcore_memory_sections (obfd) == 0) error (_("gcore: failed to get corefile memory sections from target.")); /* Write out the contents of the note section. */ if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_size)) warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ())); do_cleanups (cleanup); }
void bfd_nonfatal (const char *string) { const char *errmsg = bfd_errmsg (bfd_get_error ()); if (string) o_fmessage (stderr, "ERROR: %s: %s\n", string, errmsg); else o_fmessage (stderr, "ERROR: %s\n", errmsg); }
/* Read inferior memory at ADDR to find the header of a loaded object file and read its in-core symbols out of inferior memory. 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, 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; 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, &loadbase, target_read_memory); if (nbfd == NULL) error (_("Failed to read a valid object file image from memory.")); if (name == NULL) nbfd->filename = xstrdup ("shared object read from target memory"); else nbfd->filename = name; if (!bfd_check_format (nbfd, bfd_object)) { /* 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). */ bfd_close (nbfd); 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; } objf = symbol_file_add_from_bfd (nbfd, from_tty ? SYMFILE_VERBOSE : 0, sai, OBJF_SHARED); /* This might change our ideas about frames already looked at. */ reinit_frame_cache (); return objf; }
trap::ExecLoader::~ExecLoader() { if (this->exec_image != NULL) { if (!bfd_close_all_done(this->exec_image)) { //An Error has occurred; lets see what it is THROW_ERROR("Cannot close binary parser: " << bfd_errmsg(bfd_get_error()) << '.'); } } if (this->program_data != NULL) { delete [] this->program_data; } } // ExecLoader::~ExecLoader()
static int c2_flash_file(struct c2tool_state *state, const char *filename, const char *target, unsigned int offset) { bfd *ibfd; struct flash_section_data fsdata = { state, offset }; ibfd = bfd_openr(filename, target); if (ibfd == NULL) { fprintf(stderr, "%s\n", bfd_errmsg(bfd_get_error())); return -EINVAL; } if (!bfd_check_format(ibfd, bfd_object)) { fprintf(stderr, "%s\n", bfd_errmsg(bfd_get_error())); return -EINVAL; } bfd_map_over_sections(ibfd, flash_section, &fsdata); return 0; }
void bfd_nonfatal (const char *string) { const char *errmsg; errmsg = bfd_errmsg (bfd_get_error ()); fflush (stdout); if (string) fprintf (stderr, "%s: %s: %s\n", program_name, string, errmsg); else fprintf (stderr, "%s: %s\n", program_name, errmsg); }
static symbolS * obj_coff_common_parse (int ignore ATTRIBUTE_UNUSED, symbolS *symbolP, addressT size) { addressT align = 0; if (*input_line_pointer == ',') { align = parse_align (0); if (align == (addressT) -1) return NULL; } S_SET_VALUE (symbolP, size); S_SET_EXTERNAL (symbolP); S_SET_SEGMENT (symbolP, bfd_com_section_ptr); symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT; /* There is no S_SET_ALIGN (symbolP, align) in COFF/PE. Instead we must add a note to the .drectve section. */ if (align) { segT current_seg = now_seg; subsegT current_subseg = now_subseg; flagword oldflags; asection *sec; size_t pfxlen, numlen; char *frag; char numbuff[20]; sec = subseg_new (".drectve", 0); oldflags = bfd_get_section_flags (stdoutput, sec); if (oldflags == SEC_NO_FLAGS) { if (!bfd_set_section_flags (stdoutput, sec, TC_COFF_SECTION_DEFAULT_ATTRIBUTES)) as_warn (_("error setting flags for \"%s\": %s"), bfd_section_name (stdoutput, sec), bfd_errmsg (bfd_get_error ())); } /* Emit a string. Note no NUL-termination. */ pfxlen = strlen (" -aligncomm:") + 2 + strlen (S_GET_NAME (symbolP)) + 1; numlen = snprintf (numbuff, sizeof (numbuff), "%d", (int) align); frag = frag_more (pfxlen + numlen); (void) sprintf (frag, " -aligncomm:\"%s\",", S_GET_NAME (symbolP)); memcpy (frag + pfxlen, numbuff, numlen); /* Restore original subseg. */ subseg_set (current_seg, current_subseg); } return symbolP; }
static gdb_bfd_ref_ptr macho_check_dsym (struct objfile *objfile, std::string *filenamep) { size_t name_len = strlen (objfile_name (objfile)); size_t dsym_len = strlen (DSYM_SUFFIX); const char *base_name = lbasename (objfile_name (objfile)); size_t base_len = strlen (base_name); char *dsym_filename = (char *) alloca (name_len + dsym_len + base_len + 1); bfd_mach_o_load_command *main_uuid; bfd_mach_o_load_command *dsym_uuid; strcpy (dsym_filename, objfile_name (objfile)); strcpy (dsym_filename + name_len, DSYM_SUFFIX); strcpy (dsym_filename + name_len + dsym_len, base_name); if (access (dsym_filename, R_OK) != 0) return NULL; if (bfd_mach_o_lookup_command (objfile->obfd, BFD_MACH_O_LC_UUID, &main_uuid) == 0) { warning (_("can't find UUID in %s"), objfile_name (objfile)); return NULL; } gdb_bfd_ref_ptr dsym_bfd (gdb_bfd_openr (dsym_filename, gnutarget)); if (dsym_bfd == NULL) { warning (_("can't open dsym file %s"), dsym_filename); return NULL; } if (!bfd_check_format (dsym_bfd.get (), bfd_object)) { warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ())); return NULL; } if (bfd_mach_o_lookup_command (dsym_bfd.get (), BFD_MACH_O_LC_UUID, &dsym_uuid) == 0) { warning (_("can't find UUID in %s"), dsym_filename); return NULL; } if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid, sizeof (main_uuid->command.uuid.uuid))) { warning (_("dsym file UUID doesn't match the one in %s"), objfile_name (objfile)); return NULL; } *filenamep = std::string (dsym_filename); return dsym_bfd; }
/* 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 int bfd_error(const char *string) { const char *errmsg; errmsg = bfd_errmsg(bfd_get_error()); fflush(stdout); if (string) pr_debug("%s: %s\n", string, errmsg); else pr_debug("%s\n", errmsg); return -1; }
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 ())); }
static bfd * bfd_openr_with_cleanup(const char *filename, const char *target) { bfd *ibfd; ibfd = bfd_openr(filename, target); if (ibfd == NULL) error(_("Failed to open %s: %s."), filename, bfd_errmsg(bfd_get_error())); make_cleanup_bfd_close(ibfd); if (!bfd_check_format(ibfd, bfd_object)) error(_("'%s' is not a recognized file format."), filename); return ibfd; }
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 output_file_close (char *filename) { bfd_boolean res; if (stdoutput == NULL) return; /* Close the bfd. */ res = bfd_close (stdoutput); /* Prevent an infinite loop - if the close failed we will call as_fatal which will call xexit() which may call this function again... */ stdoutput = NULL; if (! res) as_fatal (_("can't close %s: %s"), filename, bfd_errmsg (bfd_get_error ())); }
/// Initializes the loader of executable files by creating the corresponding bfd /// image of the executable file specified as parameter. trap::ExecLoader::ExecLoader(std::string filename, bool plain_file) : plain_file(plain_file) { this->program_data = NULL; this->exec_image = NULL; this->program_dim = 0; this->data_start = 0; char** matching = NULL; if (plain_file) { /// Read the input file, putting all the bytes of its content in the /// program_data array. boost::filesystem::path file_path = boost::filesystem::system_complete(boost::filesystem::path(filename)); if (!boost::filesystem::exists(file_path)) { THROW_EXCEPTION("Path " << filename << " specified in the executable loader does not exist."); } std::ifstream plain_exec_file ile(filename.c_str(), std::ifstream::in | std::ifstream::binary); if (!plain_exec_file.good()) THROW_EXCEPTION("Cannot open file " << filename << '.'); // Determine the size of the program being loaded. plain_exec_file.seekg (0, std::ios::end); this->program_dim = plain_exec_file.tellg(); plain_exec_file.seekg (0, std::ios::beg); this->program_data = new unsigned char[this->program_dim]; // Read the whole file plain_exec_file.read((char*)this->program_data, this->program_dim); this->data_start = 0; plain_exec_file.close(); } else { bfd_init(); this->exec_image = bfd_openr(filename.c_str(), "default"); if (this->exec_image == NULL) { THROW_ERROR("Cannot open input file " << filename << ": " << bfd_errmsg(bfd_get_error()) << '.'); } if (bfd_check_format (this->exec_image, bfd_archive)) { THROW_ERROR("Invalid input file " << filename << ", expected executable file, not archive."); } if (!bfd_check_format_matches (this->exec_image, bfd_object, &matching)) { THROW_ERROR("Invalid input file " << filename << ", the input file is not an object file or the target is ambiguous: " << this->get_matching_formats(matching) << '.'); } this->load_program_data(); } } // ExecLoader::ExecLoader()