/* Write resource file */ void write_res_file (const char *fn,const rc_res_directory *resdir) { asection *sec; rc_uint_type language; bfd *abfd; windres_bfd wrbfd; unsigned long sec_length = 0,sec_length_wrote; static const bfd_byte sign[] = {0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; filename = fn; abfd = windres_open_as_binary (filename, 0); sec = bfd_make_section (abfd, ".data"); if (sec == NULL) bfd_fatal ("bfd_make_section"); if (! bfd_set_section_flags (abfd, sec, (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA))) bfd_fatal ("bfd_set_section_flags"); /* Requiring this is probably a bug in BFD. */ sec->output_section = sec; set_windres_bfd (&wrbfd, abfd, sec, (target_is_bigendian ? WR_KIND_BFD_BIN_B : WR_KIND_BFD_BIN_L)); language = -1; sec_length = write_res_directory ((windres_bfd *) NULL, 0x20UL, resdir, (const rc_res_id *) NULL, (const rc_res_id *) NULL, &language, 1); if (! bfd_set_section_size (abfd, sec, (sec_length + 3) & ~3)) bfd_fatal ("bfd_set_section_size"); if ((sec_length & 3) != 0) set_windres_bfd_content (&wrbfd, sign, sec_length, 4-(sec_length & 3)); set_windres_bfd_content (&wrbfd, sign, 0, sizeof (sign)); language = -1; sec_length_wrote = write_res_directory (&wrbfd, 0x20UL, resdir, (const rc_res_id *) NULL, (const rc_res_id *) NULL, &language, 1); if (sec_length != sec_length_wrote) fatal ("res write failed with different sizes (%lu/%lu).", (long) sec_length, (long) sec_length_wrote); bfd_close (abfd); return; }
static void dump_bfd_file (char *filename, char *mode, char *target, CORE_ADDR vaddr, char *buf, int len) { bfd *obfd; asection *osection; obfd = bfd_openw_with_cleanup (filename, target, mode); osection = bfd_make_section_anyway (obfd, ".newsec"); bfd_set_section_size (obfd, osection, len); (((osection)->vma = (osection)->lma= (vaddr)), ((osection)->user_set_vma = (boolean)true), true); (((osection)->alignment_power = (0)),true); bfd_set_section_flags (obfd, osection, 0x203); osection->entsize = 0; bfd_set_section_contents (obfd, osection, buf, 0, len); }
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); }
/* FIXME: add comment: */ static void dump_bfd_file(const char *filename, const char *mode, const char *target, CORE_ADDR vaddr, const bfd_byte *buf, int len) { bfd *obfd; asection *osection; obfd = bfd_openw_with_cleanup(filename, target, mode); osection = bfd_make_section_anyway(obfd, ".newsec"); bfd_set_section_size(obfd, osection, len); if (bfd_set_section_vma(obfd, osection, vaddr)) { ; } if (bfd_set_section_alignment(obfd, osection, 0)) { ; } bfd_set_section_flags(obfd, osection, (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD)); osection->entsize = 0; bfd_set_section_contents(obfd, osection, buf, 0, len); }
static void mips_elf32_after_open() { /* Call the standard elf routine. */ gldelf32ltsmip_after_open (); #ifdef SUPPORT_EMBEDDED_RELOCS if (command_line.embedded_relocs && (! link_info.relocateable)) { bfd *abfd; /* In the embedded relocs mode we create a .rel.sdata section for each input file with a .sdata section which has has relocations. The BFD backend will fill in these sections with magic numbers which can be used to relocate the data section at run time. */ for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link_next) { asection *datasec; /* As first-order business, make sure that each input BFD is ELF. We need to call a special BFD backend function to generate the embedded relocs, and we have that function only for ELF */ if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) einfo ("%F%B: all input objects must be ELF for --embedded-relocs\n"); if (bfd_get_arch_size (abfd) != 32) einfo ("%F%B: all input objects must be 32-bit ELF for --embedded-relocs\n"); datasec = bfd_get_section_by_name (abfd, ".sdata"); /* Note that we assume that the reloc_count field has already been set up. We could call bfd_get_reloc_upper_bound, but that returns the size of a memory buffer rather than a reloc count. We do not want to call bfd_canonicalize_reloc, because although it would always work it would force us to read in the relocs into BFD canonical form, which would waste a significant amount of time and memory. */ if (datasec != NULL && datasec->reloc_count > 0) { asection *relsec; relsec = bfd_make_section (abfd, ".rel.sdata"); if (relsec == NULL || ! bfd_set_section_flags (abfd, relsec, (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY)) || ! bfd_set_section_alignment (abfd, relsec, (32 == 32) ? 2 : 3) || ! bfd_set_section_size (abfd, relsec, datasec->reloc_count * ((32 / 8) + 8))) einfo ("%F%B: cannot create .rel.sdata section: %E\n"); } /* Double check that all other data sections have no relocs, as is required for embedded PIC code. */ bfd_map_over_sections (abfd, mips_elf32_check_sections, (PTR) datasec); } } #endif /* SUPPORT_EMBEDDED_RELOCS */ }
static void gcore_command (char *args, int from_tty) { struct cleanup *old_chain; char *corefilename, corefilename_buffer[40]; asection *note_sec = NULL; bfd *obfd; void *note_data = NULL; int note_size = 0; /* No use generating a corefile without a target process. */ if (!target_has_execution) noprocess (); if (args && *args) corefilename = args; else { /* Default corefile name is "core.PID". */ sprintf (corefilename_buffer, "core.%d", PIDGET (inferior_ptid)); corefilename = corefilename_buffer; } if (info_verbose) fprintf_filtered (gdb_stdout, "Opening corefile '%s' for output.\n", corefilename); /* Open the output file. */ obfd = bfd_openw (corefilename, default_gcore_target ()); if (!obfd) error (_("Failed to open '%s' for output."), corefilename); /* Need a cleanup that will close the file (FIXME: delete it?). */ old_chain = make_cleanup_bfd_close (obfd); bfd_set_format (obfd, bfd_core); bfd_set_arch_mach (obfd, default_gcore_arch (), default_gcore_mach ()); /* An external target method must build the notes section. */ note_data = target_make_corefile_notes (obfd, ¬e_size); /* Create the note section. */ if (note_data != NULL && note_size != 0) { 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 (note_data != NULL && note_size != 0) { if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_size)) warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ())); } /* Succeeded. */ fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename); /* Clean-ups will close the output file and free malloc memory. */ do_cleanups (old_chain); return; }
void replace_hello(const char *input_path, const char *output_path) { bfd_init(); bfd *ibfd = bfd_openr(input_path, NULL); if (ibfd == NULL) errx(1, bfd_errmsg(bfd_get_error())); if (!bfd_check_format(ibfd, bfd_object)) { bfd_close_all_done(ibfd); errx(1, "Input file is not a valid object file."); } bfd *obfd = bfd_openw(output_path, bfd_get_target(ibfd)); if (obfd == NULL) { bfd_close_all_done(ibfd); errx(1, bfd_errmsg(bfd_get_error())); } if (!bfd_set_format(obfd, bfd_get_format(ibfd))) { bfd_close_all_done(ibfd); bfd_close_all_done(obfd); errx(1, "Setting obfd format failed: %s\n", bfd_errmsg(bfd_get_error())); } bfd_set_arch_info(obfd, bfd_get_arch_info(ibfd)); // Create sections for .data asection *section = bfd_get_section_by_name(ibfd, ".data"); while (section != NULL) { if (section->flags & SEC_HAS_CONTENTS) { char *section_contents = (char *)malloc(section->size); bfd_get_section_contents(ibfd, section, section_contents, 0, section->size); char *hello_pos = (char *)memmem(section_contents, section->size, "hello", 5); if (hello_pos != NULL) { if (bfd_make_section_anyway_with_flags(obfd, ".data", section->flags) == NULL) { free(section_contents); bfd_close_all_done(ibfd); bfd_close_all_done(obfd); errx(1, bfd_errmsg(bfd_get_error())); } } free(section_contents); } section = bfd_get_next_section_by_name(ibfd, section); } asection *comment_section = bfd_make_section_anyway_with_flags(obfd, ".comment.my_objcopy", SEC_HAS_CONTENTS); if (comment_section == NULL) { bfd_close_all_done(ibfd); bfd_close_all_done(obfd); errx(1, bfd_errmsg(bfd_get_error())); } if (!bfd_set_section_size(obfd, comment_section, 3)) { bfd_close_all_done(ibfd); bfd_close_all_done(obfd); errx(1, bfd_errmsg(bfd_get_error())); } if (!bfd_set_section_contents(obfd, comment_section, "moo", 0, 3)) { bfd_close_all_done(ibfd); bfd_close_all_done(obfd); errx(1, bfd_errmsg(bfd_get_error())); } // section = bfd_get_section_by_name(ibfd, ".data"); // asection *osection = bfd_get_section_by_name(obfd, ".data"); // if (osection == NULL) { // bfd_close_all_done(ibfd); // bfd_close_all_done(obfd); // errx(1, bfd_errmsg(bfd_get_error())); // } // while (section != NULL) { // if (section->flags & SEC_HAS_CONTENTS) { // char *section_contents = (char *)malloc(section->size); // bfd_get_section_contents(ibfd, section, section_contents, 0, section->size); // // char *hello_pos = (char *)memmem(section_contents, section->size, "hello", 5); // if (hello_pos != NULL) { // hello_pos[1] = 'o'; // hello_pos[4] = 'a'; // if (bfd_set_section_contents(obfd, osection, section_contents, 0, section->size)) { // free(section_contents); // bfd_close_all_done(ibfd); // bfd_close_all_done(obfd); // errx(1, bfd_errmsg(bfd_get_error())); // } // } // // free(section_contents); // osection = bfd_get_next_section_by_name(obfd, osection); // } // // section = bfd_get_next_section_by_name(ibfd, section); // } if (!bfd_close(obfd)) errx(1, "Closing obfd failed: %s\n", bfd_errmsg(bfd_get_error())); if (!bfd_close(ibfd)) errx(1, "Closing ibfd failed: %s\n", bfd_errmsg(bfd_get_error())); }
static void emit_so_bfd(const Chunk *base, uint64_t textOffs, uint64_t textLen, std::vector<MethBlock> &blocks, std::vector<DebugInfo> &debugInfos) { bfd_init(); bfd *abfd = bfd_openw("jit.o", #ifdef __MACH__ "mach-o-i386" #else "elf32-i386" #endif ) ; bfd_set_format(abfd, bfd_object); #ifdef __MACH__ bfd_set_arch_mach(abfd, bfd_arch_i386, bfd_mach_i386_i386); #else bfd_set_arch_mach(abfd, bfd_arch_i386, bfd_mach_i386_i386); #endif asection *textSection = bfd_make_section(abfd, ".text"); bfd_set_section_flags( abfd, textSection, SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_HAS_CONTENTS); #ifdef __MACH__ bfd_set_section_size(abfd, textSection, textLen); // for mach-o, the .o we generate is linked into a .dylib // so just set the alignment to make sure things end up // in the right place after link textSection->alignment_power = l2(textOffs); static const uint64_t textAdj = 0; #else bfd_set_section_size(abfd, textSection, textLen + textOffs); // for linux (and oprofile) the generated object is used // directly, so just offset the symbols uint64_t textAdj = textOffs; #endif asymbol **symbols = (asymbol **) malloc( sizeof(asymbol *) * (6 + blocks.size())); uint64_t start = ((uint64_t *) base->data)[0] + textOffs; int n = 0; std::map<std::string, int> namesSeen; std::vector<MethBlock>::const_iterator i, e; symbols[n++] = make_glob_symbol(abfd, "__jitStart", textSection, textAdj); symbols[n++] = make_glob_symbol(abfd, "_jitStart", textSection, textAdj); for (i = blocks.begin(), e = blocks.end(); i != e; i++, n++) { std::string name = i->name(); int seen = namesSeen[name]++; if (seen) { char buf[16]; sprintf(buf, " (%d)", seen); name += buf; } symbols[n] = make_glob_symbol(abfd, name.c_str(), textSection, i->start() - start + textAdj); } symbols[n++] = make_glob_symbol(abfd, "__jitUnused", textSection, blocks.back().end() - start + textAdj); symbols[n++] = make_glob_symbol(abfd, "_jitUnused", textSection, blocks.back().end() - start + textAdj); symbols[n++] = make_glob_symbol(abfd, "__jitEnd", textSection, textLen + textAdj); symbols[n++] = make_glob_symbol(abfd, "_jitEnd", textSection, textLen + textAdj); bfd_set_symtab(abfd, symbols, n); for (i = blocks.begin(), e = blocks.end(); i != e; i++, n++) if (i->codeBytes()) bfd_set_section_contents(abfd, textSection, i->codeBytes(), i->start() - start, i->codeLen()); bfd_close(abfd); for (int n = 0; n < blocks.size(); n++) free((void *) symbols[n]->name); free(symbols); }
static void setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg) { bfd *obfd = obfdarg; struct section_list *p; sec_ptr osection; bfd_size_type size; bfd_vma vma; bfd_vma lma; const char *err; const char * name; name = bfd_section_name (ibfd, isection); osection = bfd_make_section_anyway (obfd, name); if (osection == NULL) { perror("setup_section: making"); } size = bfd_section_size (ibfd, isection); if (! bfd_set_section_size (obfd, osection, size)) { perror("setup_section: size"); } vma = bfd_section_vma (ibfd, isection); if (! bfd_set_section_vma (obfd, osection, vma)) { perror("setup_section: vma"); } lma = isection->lma; osection->lma = lma; /* FIXME: This is probably not enough. If we change the LMA we may have to recompute the header for the file as well. */ if (!bfd_set_section_alignment (obfd, osection, bfd_section_alignment (ibfd, isection))) { perror("setup_section: alignment"); } if (!bfd_set_section_flags (obfd, osection, bfd_get_section_flags(ibfd, isection))) { perror("setup_section: flags"); } /* Copy merge entity size. */ osection->entsize = isection->entsize; /* This used to be mangle_section; we do here to avoid using bfd_get_section_by_name since some formats allow multiple sections with the same name. */ isection->output_section = osection; isection->output_offset = 0; /* Allow the BFD backend to copy any private data it understands from the input section to the output section. */ if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection)) { perror("setup_section: private data"); } /* All went well. */ return; perror("setup_section: %s: section `%s': error in %s: %s"), bfd_get_filename (ibfd), bfd_section_name (ibfd, isection), err, bfd_errmsg (bfd_get_error ()); }
static void macho_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) { bfd *abfd = objfile->obfd; long storage_needed; std::vector<oso_el> oso_vector; /* We have to hold on to the symbol table until the call to macho_symfile_read_all_oso at the end of this function. */ gdb::def_vector<asymbol *> symbol_table; /* Get symbols from the symbol table only if the file is an executable. The symbol table of object files is not relocated and is expected to be in the executable. */ if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) { std::string dsym_filename; /* Process the normal symbol table first. */ storage_needed = bfd_get_symtab_upper_bound (objfile->obfd); if (storage_needed < 0) error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd), bfd_errmsg (bfd_get_error ())); if (storage_needed > 0) { long symcount; symbol_table.resize (storage_needed / sizeof (asymbol *)); minimal_symbol_reader reader (objfile); symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table.data ()); if (symcount < 0) error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd), bfd_errmsg (bfd_get_error ())); macho_symtab_read (reader, objfile, symcount, symbol_table.data (), &oso_vector); reader.install (); } /* Try to read .eh_frame / .debug_frame. */ /* First, locate these sections. We ignore the result status as it only checks for debug info. */ dwarf2_has_info (objfile, NULL); dwarf2_build_frame_info (objfile); /* Check for DSYM file. */ gdb_bfd_ref_ptr dsym_bfd (macho_check_dsym (objfile, &dsym_filename)); if (dsym_bfd != NULL) { struct bfd_section *asect, *dsect; if (mach_o_debug_level > 0) printf_unfiltered (_("dsym file found\n")); /* Set dsym section size. */ for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections; asect && dsect; asect = asect->next, dsect = dsect->next) { if (strcmp (asect->name, dsect->name) != 0) break; bfd_set_section_size (dsym_bfd.get (), dsect, bfd_get_section_size (asect)); } /* Add the dsym file as a separate file. */ symbol_file_add_separate (dsym_bfd.get (), dsym_filename.c_str (), symfile_flags, objfile); /* Don't try to read dwarf2 from main file or shared libraries. */ return; } } if (dwarf2_has_info (objfile, NULL)) { /* DWARF 2 sections */ dwarf2_build_psymtabs (objfile); } /* Then the oso. */ if (!oso_vector.empty ()) macho_symfile_read_all_oso (&oso_vector, objfile, symfile_flags); }