mirror of
https://github.com/darlinghq/darling-gdb.git
synced 2024-12-05 02:47:05 +00:00
eea6121ac0
* section.c (struct sec): Rename "_cooked_size" to "size". Rename "_raw_size" to "rawsize". (STD_SECTION): Adjust comments. (bfd_set_section_size, bfd_get_section_contents): Use size. (bfd_malloc_and_get_section): New function. * bfd-in.h (bfd_section_size, bfd_get_section_size): Use size. * coff-sh.c (sh_relax_section): Alloc coff_section_data struct early. Correctly free reloc and contents memory. * elf-eh-frame.c (_bfd_elf_discard_section_eh_frame): Delete FIXME and fake CIE now that we can shink section size to zero. (_bfd_elf_write_section_eh_frame): Likewise.. * elf32-ppc.c (ppc_elf_relax_section): Delay reading section contents. * elf-m10300.c (mn10300_elf_final_link_relocate): Don't use _bfd_stab_section_offset. Use _bfd_elf_section_offset. * stabs.c (_bfd_stab_section_offset_): Remove unused args and unneeded indirection. * elf.c (_bfd_elf_section_offset): .. and update call. * libbfd-in.h (_bfd_stab_section_offset): Update prototype. * libbfd.h: Regenerate. * bfd-in2.h: Regenerate. Replace occurrences of "_raw_size" and "_cooked_size" in most places with "size". Set new "rawsize" for stabs, eh_frame, and SEC_MERGE sections. Use "rawsize", if non-zero, for bfd_get_section_contents calls if the section might be a stabs, eh_frame, or SEC_MERGE section. Similarly use "rawsize", if non-zero, in reloc functions to validate reloc addresses. Use new bfd_malloc_and_get_section in most places where bfd_get_section_contents was called. Expand all occurrences of bfd_section_size and bfd_get_section_size. Rename "raw_size" var in grok_prstatus and similar functions to "size". * aix386-core.c (aix386_core_file_p): .. * aix5ppc-core.c (xcoff64_core_p): .. * aout-adobe.c (aout_adobe_callback, aout_adobe_write_object_contents, aout_adobe_set_section_contents): .. * aout-target.h (callback): .. * aout-tic30.c (tic30_aout_callback, tic30_aout_final_link_relocate, MY_bfd_final_link): .. * aoutf1.h (sunos4_core_file_p): .. * aoutx.h (some_aout_object_p, adjust_o_magic, adjust_z_magic, adjust_n_magic, adjust_sizes_and_vmas, translate_from_native_sym_flags, final_link, aout_link_input_section): .. * binary.c (binary_object_p, binary_canonicalize_symtab, binary_set_section_contents): .. * bout.c (b_out_callback, b_out_write_object_contents, b_out_set_section_contents, b_out_bfd_relax_section, b_out_bfd_get_relocated_section_contents): .. * cisco-core.c (cisco_core_file_validate): .. * coff-alpha.c (alpha_ecoff_object_p, alpha_ecoff_get_relocated_section_conten, alpha_relocate_section): .. * coff-arm.c (coff_arm_relocate_section, bfd_arm_allocate_interworking_sections): .. * coff-h8300.c (h8300_reloc16_extra_cases, h8300_bfd_link_add_symbols): .. * coff-mips.c (mips_refhi_reloc, mips_gprel_reloc): .. * coff-ppc.c (coff_ppc_relocate_section, ppc_allocate_toc_section, ppc_bfd_coff_final_link): .. * coff-rs6000.c (xcoff_reloc_type_br, xcoff_ppc_relocate_section): .. * coff-sh.c (sh_relax_section, sh_relax_delete_bytes, sh_align_loads, sh_coff_get_relocated_section_contents): .. * coff64-rs6000.c (xcoff64_write_object_contents, xcoff64_reloc_type_br, xcoff64_ppc_relocate_section): .. * coffcode.h (coff_compute_section_file_positions, coff_write_object_contents): .. * coffgen.c (make_a_section_from_file, coff_write_symbols, coff_section_symbol, build_debug_section): .. * cofflink.c (coff_link_add_symbols, _bfd_coff_final_link, process_embedded_commands, _bfd_coff_link_input_bfd, _bfd_coff_write_global_sym): .. * cpu-arm.c (bfd_arm_update_notes, bfd_arm_get_mach_from_notes): .. * cpu-ns32k.c (do_ns32k_reloc, _bfd_ns32k_final_link_relocate): .. * dwarf1.c (parse_line_table, _bfd_dwarf1_find_nearest_line): .. * dwarf2.c (read_indirect_string, read_abbrevs, decode_line_info, _bfd_dwarf2_find_nearest_line): .. * ecoff.c (bfd_debug_section, ecoff_set_symbol_info, ecoff_compute_section_file_positions, _bfd_ecoff_write_object_contents, ecoff_indirect_link_order): .. * elf-eh-frame.c (_bfd_elf_discard_section_eh_frame, _bfd_elf_discard_section_eh_frame_hdr, _bfd_elf_maybe_strip_eh_frame_hdr, _bfd_elf_eh_frame_section_offset, _bfd_elf_write_section_eh_frame, _bfd_elf_write_section_eh_frame_hdr): .. * elf-hppa.h (elf_hppa_sort_unwind): .. * elf-m10200.c (mn10200_elf_relax_section, mn10200_elf_relax_delete_bytes, mn10200_elf_get_relocated_section_contents): .. * elf-m10300.c (_bfd_mn10300_elf_create_got_section, mn10300_elf_check_relocs, mn10300_elf_relax_section, mn10300_elf_relax_delete_bytes, mn10300_elf_get_relocated_section_contents, _bfd_mn10300_elf_adjust_dynamic_symbol, _bfd_mn10300_elf_discard_copies, _bfd_mn10300_elf_size_dynamic_sections, _bfd_mn10300_elf_finish_dynamic_sections): .. * elf.c (_bfd_elf_print_private_bfd_data, bfd_elf_get_bfd_needed_list, _bfd_elf_make_section_from_phdr, elf_fake_sections, bfd_elf_set_group_contents, map_sections_to_segments, elf_sort_sections, assign_file_positions_for_segments, SECTION_SIZE, copy_private_bfd_data, _bfd_elf_get_dynamic_reloc_upper_bound, _bfd_elf_canonicalize_dynamic_reloc, elfcore_maybe_make_sect, _bfd_elfcore_make_pseudosection, elfcore_grok_prstatus, elfcore_grok_lwpstatus, elfcore_grok_win32pstatus, elfcore_grok_note, elfcore_grok_nto_status, elfcore_grok_nto_gregs, _bfd_elf_rel_local_sym, _bfd_elf_get_synthetic_symtab): .. * elf32-arm.h (bfd_elf32_arm_allocate_interworking_sect, bfd_elf32_arm_process_before_allocation, elf32_arm_adjust_dynamic_symbol, allocate_dynrelocs, elf32_arm_size_dynamic_sections, elf32_arm_finish_dynamic_sections, elf32_arm_write_section): .. * elf32-cris.c (cris_elf_grok_prstatus, elf_cris_finish_dynamic_sections, cris_elf_gc_sweep_hook, elf_cris_adjust_gotplt_to_got, elf_cris_adjust_dynamic_symbol, cris_elf_check_relocs, elf_cris_size_dynamic_sections, elf_cris_discard_excess_dso_dynamics, elf_cris_discard_excess_program_dynamics): .. * elf32-d30v.c (bfd_elf_d30v_reloc, bfd_elf_d30v_reloc_21): .. * elf32-dlx.c (_bfd_dlx_elf_hi16_reloc): .. * elf32-frv.c (_frvfdpic_add_dyn_reloc, _frvfdpic_add_rofixup, _frv_create_got_section, _frvfdpic_assign_plt_entries, elf32_frvfdpic_size_dynamic_sections, elf32_frvfdpic_modify_segment_map, elf32_frvfdpic_finish_dynamic_sections): .. * elf32-h8300.c (elf32_h8_relax_section, elf32_h8_relax_delete_bytes, elf32_h8_get_relocated_section_contents): .. * elf32-hppa.c (hppa_build_one_stub, hppa_size_one_stub, elf32_hppa_adjust_dynamic_symbol, allocate_plt_static, allocate_dynrelocs, elf32_hppa_size_dynamic_sections, group_sections, elf32_hppa_size_stubs, elf32_hppa_set_gp, elf32_hppa_build_stubs, elf32_hppa_finish_dynamic_sections): .. * elf32-i370.c (i370_elf_adjust_dynamic_symbol, i370_elf_size_dynamic_sections, i370_elf_check_relocs, i370_elf_finish_dynamic_sections): .. * elf32-i386.c (elf_i386_grok_prstatus, elf_i386_adjust_dynamic_symbol, allocate_dynrelocs, elf_i386_size_dynamic_sections, elf_i386_relocate_section, elf_i386_finish_dynamic_sections): .. * elf32-i860.c (i860_howto_pc26_reloc, i860_howto_pc16_reloc, i860_howto_highadj_reloc, i860_howto_splitn_reloc): .. * elf32-ip2k.c (ip2k_is_switch_table_128, ip2k_relax_switch_table_128, ip2k_is_switch_table_256, ip2k_relax_switch_table_256, ip2k_elf_relax_section, adjust_all_relocations, ip2k_elf_relax_delete_bytes): .. * elf32-m32r.c (m32r_elf_do_10_pcrel_reloc, m32r_elf_hi16_reloc, m32r_elf_generic_reloc, m32r_elf_adjust_dynamic_symbol, allocate_dynrelocs, m32r_elf_size_dynamic_sections, m32r_elf_relocate_section, m32r_elf_finish_dynamic_sections, m32r_elf_relax_section, m32r_elf_relax_delete_bytes, m32r_elf_get_relocated_section_contents): .. * elf32-m68hc11.c (m68hc11_elf_build_one_stub, m68hc11_elf_size_one_stub, m68hc11_elf_relax_section, m68hc11_elf_relax_delete_bytes): .. * elf32-m68hc12.c (m68hc12_elf_build_one_stub, m68hc12_elf_size_one_stub): .. * elf32-m68hc1x.c (elf32_m68hc11_size_stubs, elf32_m68hc11_build_stubs, m68hc11_elf_special_reloc): .. * elf32-m68k.c (elf_m68k_check_relocs, elf_m68k_gc_sweep_hook, elf_m68k_adjust_dynamic_symbol, elf_m68k_size_dynamic_sections, elf_m68k_discard_copies, elf_m68k_finish_dynamic_sections): .. * elf32-mips.c (gprel32_with_gp, mips16_gprel_reloc, elf32_mips_grok_prstatus): .. * elf32-or32.c (or32_elf_consth_reloc): .. * elf32-ppc.c (ppc_elf_relax_section, ppc_elf_addr16_ha_reloc, elf_create_pointer_linker_section, ppc_elf_create_linker_section, ppc_elf_additional_program_headers, ppc_elf_adjust_dynamic_symbol, allocate_dynrelocs, ppc_elf_size_dynamic_sections, ppc_elf_finish_dynamic_sections, ppc_elf_grok_prstatus, ppc_elf_final_write_processing): .. * elf32-s390.c (s390_elf_ldisp_reloc, elf_s390_adjust_dynamic_symbol, allocate_dynrelocs, elf_s390_size_dynamic_sections, elf_s390_finish_dynamic_sections, elf_s390_grok_prstatus): .. * elf32-sh.c (sh_elf_reloc_loop, sh_elf_relax_section, sh_elf_relax_delete_bytes, sh_elf_align_loads, sh_elf_adjust_dynamic_symbol, allocate_dynrelocs, sh_elf_size_dynamic_sections, sh_elf_get_relocated_section_contents, sh_elf_finish_dynamic_sections, elf32_shlin_grok_prstatus): .. * elf32-sh64-com.c (sh64_address_in_cranges, sh64_get_contents_type): .. * elf32-sh64.c (sh64_find_section_for_address, sh64_elf_final_write_processing): .. * elf32-sparc.c (sparc_elf_wdisp16_reloc, sparc_elf_hix22_reloc, sparc_elf_lox10_reloc, elf32_sparc_adjust_dynamic_symbol, allocate_dynrelocs, elf32_sparc_size_dynamic_sections, elf32_sparc_relocate_section, elf32_sparc_finish_dynamic_sections): .. * elf32-v850.c (v850_elf_reloc, v850_elf_relax_section): .. * elf32-vax.c (elf_vax_check_relocs, elf_vax_adjust_dynamic_symbol, elf_vax_size_dynamic_sections, elf_vax_discard_copies, elf_vax_instantiate_got_entries, elf_vax_relocate_section, elf_vax_finish_dynamic_sections): .. * elf32-xstormy16.c (xstormy16_elf_24_reloc, xstormy16_elf_check_relocs, xstormy16_relax_plt_check, xstormy16_elf_relax_section, xstormy16_elf_always_size_sections, xstormy16_elf_finish_dynamic_sections): .. * elf32-xtensa.c (xtensa_read_table_entries, elf_xtensa_allocate_got_size, elf_xtensa_allocate_local_got_size, elf_xtensa_size_dynamic_sections, elf_xtensa_do_reloc, bfd_elf_xtensa_reloc, elf_xtensa_relocate_section, elf_xtensa_combine_prop_entries, elf_xtensa_finish_dynamic_sections, elf_xtensa_discard_info_for_section, elf_xtensa_grok_prstatus, get_relocation_opcode, retrieve_contents, find_relaxable_sections, collect_source_relocs, is_resolvable_asm_expansion, remove_literals, relax_section, shrink_dynamic_reloc_sections, relax_property_section, xtensa_callback_required_dependence): .. * elf64-alpha.c (elf64_alpha_reloc_gpdisp, elf64_alpha_relax_section, elf64_alpha_check_relocs, elf64_alpha_adjust_dynamic_symbol, elf64_alpha_calc_got_offsets_for_symbol, elf64_alpha_calc_got_offsets, elf64_alpha_size_plt_section, elf64_alpha_size_plt_section_1, elf64_alpha_always_size_sections, elf64_alpha_calc_dynrel_sizes, elf64_alpha_size_rela_got_section, elf64_alpha_size_rela_got_1, elf64_alpha_size_dynamic_sections, elf64_alpha_emit_dynrel, elf64_alpha_finish_dynamic_sections, elf64_alpha_final_link): .. * elf64-hppa.c (allocate_dynrel_entries, elf64_hppa_size_dynamic_sections, elf64_hppa_finish_dynamic_sections): .. * elf64-mips.c (mips_elf64_gprel32_reloc, mips16_gprel_reloc, mips_elf64_canonicalize_dynamic_reloc, mips_elf64_slurp_reloc_table, elf64_mips_grok_prstatus): .. * elf64-mmix.c (mmix_elf_perform_relocation, mmix_elf_reloc, mmix_elf_relocate_section, mmix_elf_final_link, mmix_set_relaxable_size, _bfd_mmix_after_linker_allocation, mmix_elf_relax_section, mmix_elf_get_section_contents): .. * elf64-ppc.c (ppc64_elf_object_p, ppc64_elf_grok_prstatus, ppc64_elf_check_relocs, ppc64_elf_func_desc_adjust, ppc64_elf_adjust_dynamic_symbol, ppc64_elf_edit_opd, allocate_dynrelocs, ppc64_elf_size_dynamic_sections, ppc_build_one_stub, ppc_size_one_stub, ppc64_elf_next_toc_section, toc_adjusting_stub_needed, group_sections, ppc64_elf_size_stubs, ppc64_elf_build_stubs, ppc64_elf_relocate_section, ppc64_elf_finish_dynamic_sections): .. * elf64-s390.c (s390_elf_ldisp_reloc, elf_s390_adjust_dynamic_symbol, allocate_dynrelocs, elf_s390_size_dynamic_sections, elf_s390_finish_dynamic_sections): .. * elf64-sh64.c (sh_elf64_get_relocated_section_contents, sh_elf64_check_relocs, sh64_elf64_adjust_dynamic_symbol, sh64_elf64_discard_copies, sh64_elf64_size_dynamic_sections, sh64_elf64_finish_dynamic_sections): .. * elf64-sparc.c (sparc64_elf_slurp_reloc_table, init_insn_reloc, sparc64_elf_check_relocs, sparc64_elf_adjust_dynamic_symbol, sparc64_elf_size_dynamic_sections, sparc64_elf_relocate_section, sparc64_elf_finish_dynamic_symbol, sparc64_elf_finish_dynamic_sections): .. * elf64-x86-64.c (elf64_x86_64_grok_prstatus, elf64_x86_64_adjust_dynamic_symbol, allocate_dynrelocs, elf64_x86_64_size_dynamic_sections, elf64_x86_64_relocate_section, elf64_x86_64_finish_dynamic_sections): .. * elfarm-nabi.c (elf32_arm_nabi_grok_prstatus): .. * elfcode.h (elf_slurp_reloc_table): .. * elflink.c (_bfd_elf_create_got_section, elf_add_dt_needed_tag, elf_finalize_dynstr, elf_link_add_object_symbols, bfd_elf_size_dynamic_sections, elf_link_sort_relocs, elf_link_input_bfd, bfd_elf_final_link, bfd_elf_discard_info): .. * elfn32-mips.c (gprel32_with_gp, mips16_gprel_reloc, elf32_mips_grok_prstatus): .. * elfxx-ia64.c (elfNN_ia64_relax_section, allocate_dynrel_entries, elfNN_ia64_size_dynamic_sections, elfNN_ia64_install_dyn_reloc, elfNN_ia64_choose_gp, elfNN_ia64_final_link, elfNN_ia64_finish_dynamic_sections): .. * elfxx-mips.c (mips_elf_create_procedure_table, mips_elf_check_mips16_stubs, _bfd_mips_elf_gprel16_with_gp, _bfd_mips_elf_hi16_reloc, _bfd_mips_elf_generic_reloc, mips_elf_global_got_index, mips_elf_multi_got, mips_elf_create_compact_rel_section, mips_elf_calculate_relocation, mips_elf_allocate_dynamic_relocations, mips_elf_create_dynamic_relocation, _bfd_mips_elf_fake_sections, _bfd_mips_relax_section, _bfd_mips_elf_adjust_dynamic_symbol, _bfd_mips_elf_always_size_sections, _bfd_mips_elf_size_dynamic_sections, _bfd_mips_elf_finish_dynamic_symbol, _bfd_mips_elf_finish_dynamic_sections, _bfd_mips_elf_modify_segment_map, _bfd_mips_elf_discard_info, _bfd_mips_elf_write_section, _bfd_mips_elf_set_section_contents, _bfd_elf_mips_get_relocated_section_contents, _bfd_mips_elf_final_link, _bfd_mips_elf_merge_private_bfd_data): .. * hp300hpux.c (callback): .. * hppabsd-core.c (make_bfd_asection): .. * hpux-core.c (make_bfd_asection): .. * i386linux.c (linux_link_create_dynamic_sections, bfd_i386linux_size_dynamic_sections, linux_finish_dynamic_link): .. * i386msdos.c (msdos_write_object_contents): .. * i386os9k.c (os9k_callback, os9k_write_object_contents, os9k_set_section_contents): .. * ieee.c (parse_expression, ieee_slurp_external_symbols, ieee_slurp_sections, ieee_slurp_debug, ieee_slurp_section_data, ieee_write_section_part, do_with_relocs, do_as_repeat, do_without_relocs, ieee_write_debug_part, init_for_output, ieee_set_section_contents): .. * ihex.c (ihex_scan, ihex_read_section, ihex_get_section_contents): .. * irix-core.c (do_sections, make_bfd_asection): .. * libaout.h (aout_section_merge_with_text_p): .. * libbfd.c (_bfd_generic_get_section_contents, _bfd_generic_get_section_contents_in_window): .. * linker.c (default_indirect_link_order): .. * lynx-core.c (make_bfd_asection): .. * m68klinux.c (linux_link_create_dynamic_sections, bfd_m68klinux_size_dynamic_sections, linux_finish_dynamic_link): .. * mach-o.c (bfd_mach_o_make_bfd_section, bfd_mach_o_scan_read_dylinker, bfd_mach_o_scan_read_dylib, bfd_mach_o_scan_read_thread, bfd_mach_o_scan_read_symtab, bfd_mach_o_scan_read_segment): .. * merge.c (_bfd_add_merge_section, record_section, merge_strings, _bfd_merge_sections): .. * mmo.c (mmo_find_sec_w_addr, mmo_get_spec_section, mmo_get_loc, mmo_map_set_sizes, mmo_canonicalize_symtab, mmo_internal_write_section, mmo_write_object_contents): .. * netbsd-core.c (netbsd_core_file_p): .. * nlm32-alpha.c (nlm_alpha_read_reloc, nlm_alpha_write_import, nlm_alpha_set_public_section): .. * nlm32-ppc.c (nlm_powerpc_read_reloc, nlm_powerpc_write_reloc): .. * nlm32-sparc.c (nlm_sparc_write_import): .. * nlmcode.h (add_bfd_section, nlm_swap_auxiliary_headers_in, nlm_compute_section_file_positions): .. * oasys.c (oasys_object_p, oasys_slurp_section_data, oasys_write_sections, oasys_write_data, oasys_set_section_contents): .. * opncls.c (get_debug_link_info): .. * osf-core.c (make_bfd_asection): .. * pdp11.c (some_aout_object_p, adjust_o_magic, adjust_z_magic, adjust_n_magic, adjust_sizes_and_vmas, squirt_out_relocs, final_link, aout_link_input_section): .. * peXXigen.c (_bfd_XXi_swap_sym_in, _bfd_XXi_swap_aouthdr_out, pe_print_idata, pe_print_edata, pe_print_pdata, pe_print_reloc): .. * pef.c (bfd_pef_make_bfd_section, bfd_pef_print_loader_section, bfd_pef_scan_start_address, bfd_pef_parse_symbols): .. * ppcboot.c (ppcboot_object_p, ppcboot_canonicalize_symtab): .. * ptrace-core.c (ptrace_unix_core_file_p): .. * reloc.c (bfd_perform_relocation, bfd_install_relocation, _bfd_final_link_relocate, bfd_generic_relax_section, bfd_generic_get_relocated_section_contents): .. * reloc16.c (bfd_coff_reloc16_relax_section, bfd_coff_reloc16_get_relocated_section_c): .. * riscix.c (riscix_some_aout_object_p): .. * rs6000-core.c (read_hdr, make_bfd_asection): .. * sco5-core.c (make_bfd_asection): .. * simple.c (bfd_simple_get_relocated_section_contents): .. * som.c (som_object_setup, setup_sections, som_prep_headers, som_write_fixups, som_begin_writing, bfd_section_from_som_symbol, som_set_reloc_info, som_get_section_contents, som_bfd_link_split_section): .. * sparclinux.c (linux_link_create_dynamic_sections, bfd_sparclinux_size_dynamic_sections, linux_finish_dynamic_link): .. * srec.c (srec_scan, srec_read_section, srec_get_section_contents): .. * stabs.c (_bfd_link_section_stabs, _bfd_discard_section_stabs, _bfd_write_stab_strings, _bfd_stab_section_offset): .. * sunos.c (sunos_read_dynamic_info, sunos_create_dynamic_sections, bfd_sunos_size_dynamic_sections, sunos_scan_std_relocs, sunos_scan_ext_relocs, sunos_scan_dynamic_symbol, sunos_write_dynamic_symbol, sunos_check_dynamic_reloc, sunos_finish_dynamic_link): .. * syms.c (_bfd_stab_section_find_nearest_line): .. * tekhex.c (first_phase, tekhex_set_section_contents, tekhex_write_object_contents): .. * trad-core.c (trad_unix_core_file_p): .. * versados.c (process_esd, process_otr, process_otr): .. * vms-gsd.c (_bfd_vms_slurp_gsd, _bfd_vms_write_gsd): .. * vms-misc.c (add_new_contents): .. * vms-tir.c (check_section, new_section, _bfd_vms_write_tir): .. * vms.c (vms_set_section_contents): .. * xcofflink.c (xcoff_get_section_contents, xcoff_link_add_symbols, xcoff_sweep, bfd_xcoff_size_dynamic_sections, xcoff_build_ldsyms, _bfd_xcoff_bfd_final_link, xcoff_link_input_bfd): .. * xsym.c (bfd_sym_scan): .. See above. binutils/ * objcopy.c (copy_section): Don't set _cooked_size. include/ * bfdlink.h (struct bfd_link_order): Update comment. ld/ * ldlang.c (print_output_section_statement): Don't print size before relaxation. (IGNORE_SECTION): Remove bfd arg. Update all callers. * ldexp.c (fold_name): .. See below. * ldlang.c (section_already_linked, print_output_section_statement, print_input_section, insert_pad, size_input_section, lang_check_section_addresses, lang_size_sections_1, lang_size_sections, lang_do_assignments_1, lang_set_startof, lang_one_common, lang_reset_memory_regions, lang_process, lang_abs_symbol_at_end_of, lang_do_version_exports_section): .. * ldwrite.c (build_link_order, clone_section, ds, split_sections): .. * pe-dll.c (process_def_file, generate_reloc): .. * emultempl/elf32.em (gld${EMULATION_NAME}_find_statement_assignment, gld${EMULATION_NAME}_before_allocation): .. * emultempl/mmix-elfnmmo.em (mmix_after_allocation): .. * emultempl/sh64elf.em (sh64_elf_${EMULATION_NAME}_before_allocation, sh64_elf_${EMULATION_NAME}_after_allocation): .. * emultempl/sunos.em (gld${EMULATION_NAME}_before_allocation): .. * emultempl/xtensaelf.em (ld_assign_relative_paged_dot, ld_local_file_relocations_fit, ld_xtensa_insert_page_offsets): Use "size" instead of "_raw_size" and "_cooked_size". Expand bfd_section_size macro invocations.
2044 lines
64 KiB
C
2044 lines
64 KiB
C
/* NLM (NetWare Loadable Module) executable support for BFD.
|
||
Copyright 1993, 1994, 1995, 1998, 2000, 2001, 2002, 2003, 2004
|
||
Free Software Foundation, Inc.
|
||
|
||
Written by Fred Fish @ Cygnus Support, using ELF support as the
|
||
template.
|
||
|
||
This file is part of BFD, the Binary File Descriptor library.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 2 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program; if not, write to the Free Software
|
||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
||
|
||
#include "bfd.h"
|
||
#include "sysdep.h"
|
||
#include "libbfd.h"
|
||
#include "libnlm.h"
|
||
|
||
/* The functions in this file do not use the names they appear to use.
|
||
This file is actually compiled multiple times, once for each size
|
||
of NLM target we are using. At each size we use a different name,
|
||
constructed by the macro nlmNAME. For example, the function which
|
||
is named nlm_symbol_type below is actually named nlm32_symbol_type
|
||
in the final executable. */
|
||
|
||
#define Nlm_External_Fixed_Header NlmNAME(External_Fixed_Header)
|
||
#define Nlm_External_Version_Header NlmNAME(External_Version_Header)
|
||
#define Nlm_External_Copyright_Header NlmNAME(External_Copyright_Header)
|
||
#define Nlm_External_Extended_Header NlmNAME(External_Extended_Header)
|
||
#define Nlm_External_Custom_Header NlmNAME(External_Custom_Header)
|
||
#define Nlm_External_Cygnus_Ext_Header NlmNAME(External_Cygnus_Ext_Header)
|
||
|
||
#define nlm_symbol_type nlmNAME(symbol_type)
|
||
#define nlm_get_symtab_upper_bound nlmNAME(get_symtab_upper_bound)
|
||
#define nlm_canonicalize_symtab nlmNAME(canonicalize_symtab)
|
||
#define nlm_make_empty_symbol nlmNAME(make_empty_symbol)
|
||
#define nlm_print_symbol nlmNAME(print_symbol)
|
||
#define nlm_get_symbol_info nlmNAME(get_symbol_info)
|
||
#define nlm_get_reloc_upper_bound nlmNAME(get_reloc_upper_bound)
|
||
#define nlm_canonicalize_reloc nlmNAME(canonicalize_reloc)
|
||
#define nlm_object_p nlmNAME(object_p)
|
||
#define nlm_set_section_contents nlmNAME(set_section_contents)
|
||
#define nlm_write_object_contents nlmNAME(write_object_contents)
|
||
|
||
#define nlm_swap_fixed_header_in(abfd,src,dst) \
|
||
(nlm_swap_fixed_header_in_func(abfd)) (abfd,src,dst)
|
||
#define nlm_swap_fixed_header_out(abfd,src,dst) \
|
||
(nlm_swap_fixed_header_out_func(abfd)) (abfd,src,dst)
|
||
|
||
/* Forward declarations of static functions. */
|
||
|
||
static bfd_boolean add_bfd_section
|
||
PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));
|
||
static bfd_boolean nlm_swap_variable_header_in
|
||
PARAMS ((bfd *));
|
||
static bfd_boolean nlm_swap_variable_header_out
|
||
PARAMS ((bfd *));
|
||
static bfd_boolean find_nonzero
|
||
PARAMS ((PTR, size_t));
|
||
static bfd_boolean nlm_swap_auxiliary_headers_in
|
||
PARAMS ((bfd *));
|
||
static bfd_boolean nlm_swap_auxiliary_headers_out
|
||
PARAMS ((bfd *));
|
||
static bfd_boolean nlm_slurp_symbol_table
|
||
PARAMS ((bfd *));
|
||
static bfd_boolean nlm_slurp_reloc_fixups
|
||
PARAMS ((bfd *));
|
||
static bfd_boolean nlm_compute_section_file_positions
|
||
PARAMS ((bfd *));
|
||
static int nlm_external_reloc_compare
|
||
PARAMS ((const void *, const void *));
|
||
|
||
/* Should perhaps use put_offset, put_word, etc. For now, the two versions
|
||
can be handled by explicitly specifying 32 bits or "the long type". */
|
||
#if ARCH_SIZE == 64
|
||
#define put_word H_PUT_64
|
||
#define get_word H_GET_64
|
||
#endif
|
||
#if ARCH_SIZE == 32
|
||
#define put_word H_PUT_32
|
||
#define get_word H_GET_32
|
||
#endif
|
||
|
||
const bfd_target *
|
||
nlm_object_p (abfd)
|
||
bfd *abfd;
|
||
{
|
||
struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
|
||
bfd_boolean (*backend_object_p) PARAMS ((bfd *));
|
||
PTR x_fxdhdr = NULL;
|
||
Nlm_Internal_Fixed_Header *i_fxdhdrp;
|
||
struct nlm_obj_tdata *new_tdata = NULL;
|
||
const char *signature;
|
||
enum bfd_architecture arch;
|
||
bfd_size_type amt;
|
||
|
||
/* Some NLM formats have a prefix before the standard NLM fixed
|
||
header. */
|
||
backend_object_p = nlm_backend_object_p_func (abfd);
|
||
if (backend_object_p)
|
||
{
|
||
if (!(*backend_object_p) (abfd))
|
||
goto got_wrong_format_error;
|
||
}
|
||
|
||
/* Read in the fixed length portion of the NLM header in external format. */
|
||
amt = nlm_fixed_header_size (abfd);
|
||
x_fxdhdr = (PTR) bfd_malloc (amt);
|
||
if (x_fxdhdr == NULL)
|
||
goto got_no_match;
|
||
|
||
if (bfd_bread ((PTR) x_fxdhdr, amt, abfd) != amt)
|
||
{
|
||
if (bfd_get_error () != bfd_error_system_call)
|
||
goto got_wrong_format_error;
|
||
else
|
||
goto got_no_match;
|
||
}
|
||
|
||
/* Allocate an instance of the nlm_obj_tdata structure and hook it up to
|
||
the tdata pointer in the bfd. */
|
||
amt = sizeof (struct nlm_obj_tdata);
|
||
new_tdata = (struct nlm_obj_tdata *) bfd_zalloc (abfd, amt);
|
||
if (new_tdata == NULL)
|
||
goto got_no_match;
|
||
|
||
nlm_tdata (abfd) = new_tdata;
|
||
|
||
i_fxdhdrp = nlm_fixed_header (abfd);
|
||
nlm_swap_fixed_header_in (abfd, x_fxdhdr, i_fxdhdrp);
|
||
free (x_fxdhdr);
|
||
x_fxdhdr = NULL;
|
||
|
||
/* Check to see if we have an NLM file for this backend by matching
|
||
the NLM signature. */
|
||
signature = nlm_signature (abfd);
|
||
if (signature != NULL
|
||
&& *signature != '\0'
|
||
&& strncmp ((char *) i_fxdhdrp->signature, signature,
|
||
NLM_SIGNATURE_SIZE) != 0)
|
||
goto got_wrong_format_error;
|
||
|
||
/* There's no supported way to discover the endianess of an NLM, so test for
|
||
a sane version number after doing byte swapping appropriate for this
|
||
XVEC. (Hack alert!) */
|
||
if (i_fxdhdrp->version > 0xFFFF)
|
||
goto got_wrong_format_error;
|
||
|
||
/* There's no supported way to check for 32 bit versus 64 bit addresses,
|
||
so ignore this distinction for now. (FIXME) */
|
||
/* Swap in the rest of the required header. */
|
||
if (!nlm_swap_variable_header_in (abfd))
|
||
{
|
||
if (bfd_get_error () != bfd_error_system_call)
|
||
goto got_wrong_format_error;
|
||
else
|
||
goto got_no_match;
|
||
}
|
||
|
||
/* Add the sections supplied by all NLM's, and then read in the
|
||
auxiliary headers. Reading the auxiliary headers may create
|
||
additional sections described in the cygnus_ext header.
|
||
From this point on we assume that we have an NLM, and do not
|
||
treat errors as indicating the wrong format. */
|
||
if (!add_bfd_section (abfd, NLM_CODE_NAME,
|
||
i_fxdhdrp->codeImageOffset,
|
||
i_fxdhdrp->codeImageSize,
|
||
(SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
|
||
| SEC_RELOC))
|
||
|| !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
|
||
i_fxdhdrp->dataImageOffset,
|
||
i_fxdhdrp->dataImageSize,
|
||
(SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
|
||
| SEC_RELOC))
|
||
|| !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
|
||
(file_ptr) 0,
|
||
i_fxdhdrp->uninitializedDataSize,
|
||
SEC_ALLOC))
|
||
goto got_no_match;
|
||
|
||
if (!nlm_swap_auxiliary_headers_in (abfd))
|
||
goto got_no_match;
|
||
|
||
if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0
|
||
|| nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
|
||
abfd->flags |= HAS_RELOC;
|
||
if (nlm_fixed_header (abfd)->numberOfPublics != 0
|
||
|| nlm_fixed_header (abfd)->numberOfDebugRecords != 0
|
||
|| nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
|
||
abfd->flags |= HAS_SYMS;
|
||
|
||
arch = nlm_architecture (abfd);
|
||
if (arch != bfd_arch_unknown)
|
||
bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
|
||
|
||
abfd->flags |= EXEC_P;
|
||
bfd_get_start_address (abfd) = nlm_fixed_header (abfd)->codeStartOffset;
|
||
|
||
return (abfd->xvec);
|
||
|
||
got_wrong_format_error:
|
||
bfd_set_error (bfd_error_wrong_format);
|
||
got_no_match:
|
||
nlm_tdata (abfd) = preserved_tdata;
|
||
if (new_tdata != NULL)
|
||
bfd_release (abfd, new_tdata);
|
||
if (x_fxdhdr != NULL)
|
||
free (x_fxdhdr);
|
||
return (NULL);
|
||
}
|
||
|
||
/* Add a section to the bfd. */
|
||
|
||
static bfd_boolean
|
||
add_bfd_section (abfd, name, offset, size, flags)
|
||
bfd *abfd;
|
||
char *name;
|
||
file_ptr offset;
|
||
bfd_size_type size;
|
||
flagword flags;
|
||
{
|
||
asection *newsect;
|
||
|
||
newsect = bfd_make_section (abfd, name);
|
||
if (newsect == NULL)
|
||
return FALSE;
|
||
|
||
newsect->vma = 0; /* NLM's are relocatable. */
|
||
newsect->size = size;
|
||
newsect->filepos = offset;
|
||
newsect->flags = flags;
|
||
newsect->alignment_power = bfd_log2 ((bfd_vma) 0); /* FIXME */
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/* Read and swap in the variable length header. All the fields must
|
||
exist in the NLM, and must exist in the order they are read here. */
|
||
|
||
static bfd_boolean
|
||
nlm_swap_variable_header_in (abfd)
|
||
bfd *abfd;
|
||
{
|
||
unsigned char temp[NLM_TARGET_LONG_SIZE];
|
||
bfd_size_type amt;
|
||
|
||
/* Read the description length and text members. */
|
||
|
||
amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
|
||
if (bfd_bread ((PTR) &nlm_variable_header (abfd)->descriptionLength,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
amt = nlm_variable_header (abfd)->descriptionLength + 1;
|
||
if (bfd_bread ((PTR) nlm_variable_header (abfd)->descriptionText,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
|
||
/* Read and convert the stackSize field. */
|
||
|
||
amt = sizeof (temp);
|
||
if (bfd_bread ((PTR) temp, amt, abfd) != amt)
|
||
return FALSE;
|
||
nlm_variable_header (abfd)->stackSize = get_word (abfd, (bfd_byte *) temp);
|
||
|
||
/* Read and convert the reserved field. */
|
||
|
||
amt = sizeof (temp);
|
||
if (bfd_bread ((PTR) temp, amt, abfd) != amt)
|
||
return FALSE;
|
||
nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp);
|
||
|
||
/* Read the oldThreadName field. This field is a fixed length string. */
|
||
|
||
amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
|
||
if (bfd_bread ((PTR) nlm_variable_header (abfd)->oldThreadName,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
|
||
/* Read the screen name length and text members. */
|
||
|
||
amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
|
||
if (bfd_bread ((PTR) & nlm_variable_header (abfd)->screenNameLength,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
amt = nlm_variable_header (abfd)->screenNameLength + 1;
|
||
if (bfd_bread ((PTR) nlm_variable_header (abfd)->screenName,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
|
||
/* Read the thread name length and text members. */
|
||
|
||
amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
|
||
if (bfd_bread ((PTR) & nlm_variable_header (abfd)->threadNameLength,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
amt = nlm_variable_header (abfd)->threadNameLength + 1;
|
||
if (bfd_bread ((PTR) nlm_variable_header (abfd)->threadName,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
/* Swap and write out the variable length header. All the fields must
|
||
exist in the NLM, and must exist in this order. */
|
||
|
||
static bfd_boolean
|
||
nlm_swap_variable_header_out (abfd)
|
||
bfd *abfd;
|
||
{
|
||
unsigned char temp[NLM_TARGET_LONG_SIZE];
|
||
bfd_size_type amt;
|
||
|
||
/* Write the description length and text members. */
|
||
amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
|
||
if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->descriptionLength, amt,
|
||
abfd) != amt)
|
||
return FALSE;
|
||
amt = nlm_variable_header (abfd)->descriptionLength + 1;
|
||
if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->descriptionText, amt,
|
||
abfd) != amt)
|
||
return FALSE;
|
||
|
||
/* Convert and write the stackSize field. */
|
||
put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->stackSize,
|
||
(bfd_byte *) temp);
|
||
amt = sizeof (temp);
|
||
if (bfd_bwrite ((PTR) temp, amt, abfd) != amt)
|
||
return FALSE;
|
||
|
||
/* Convert and write the reserved field. */
|
||
put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved,
|
||
(bfd_byte *) temp);
|
||
amt = sizeof (temp);
|
||
if (bfd_bwrite ((PTR) temp, amt, abfd) != amt)
|
||
return FALSE;
|
||
|
||
/* Write the oldThreadName field. This field is a fixed length string. */
|
||
amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
|
||
if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->oldThreadName, amt,
|
||
abfd) != amt)
|
||
return FALSE;
|
||
|
||
/* Write the screen name length and text members. */
|
||
amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
|
||
if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->screenNameLength, amt,
|
||
abfd) != amt)
|
||
return FALSE;
|
||
amt = nlm_variable_header (abfd)->screenNameLength + 1;
|
||
if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->screenName, amt,
|
||
abfd) != amt)
|
||
return FALSE;
|
||
|
||
/* Write the thread name length and text members. */
|
||
amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
|
||
if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->threadNameLength, amt,
|
||
abfd) != amt)
|
||
return FALSE;
|
||
amt = nlm_variable_header (abfd)->threadNameLength + 1;
|
||
if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->threadName, amt,
|
||
abfd) != amt)
|
||
return FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
/* Read and swap in the contents of all the auxiliary headers. Because of
|
||
the braindead design, we have to do strcmps on strings of indeterminate
|
||
length to figure out what each auxiliary header is. Even worse, we have
|
||
no way of knowing how many auxiliary headers there are or where the end
|
||
of the auxiliary headers are, except by finding something that doesn't
|
||
look like a known auxiliary header. This means that the first new type
|
||
of auxiliary header added will break all existing tools that don't
|
||
recognize it. */
|
||
|
||
static bfd_boolean
|
||
nlm_swap_auxiliary_headers_in (abfd)
|
||
bfd *abfd;
|
||
{
|
||
char tempstr[16];
|
||
file_ptr position;
|
||
bfd_size_type amt;
|
||
|
||
for (;;)
|
||
{
|
||
position = bfd_tell (abfd);
|
||
amt = sizeof (tempstr);
|
||
if (bfd_bread ((PTR) tempstr, amt, abfd) != amt)
|
||
return FALSE;
|
||
if (bfd_seek (abfd, position, SEEK_SET) != 0)
|
||
return FALSE;
|
||
if (strncmp (tempstr, "VeRsIoN#", 8) == 0)
|
||
{
|
||
Nlm_External_Version_Header thdr;
|
||
|
||
amt = sizeof (thdr);
|
||
if (bfd_bread ((PTR) &thdr, amt, abfd) != amt)
|
||
return FALSE;
|
||
memcpy (nlm_version_header (abfd)->stamp, thdr.stamp,
|
||
sizeof (thdr.stamp));
|
||
nlm_version_header (abfd)->majorVersion =
|
||
get_word (abfd, (bfd_byte *) thdr.majorVersion);
|
||
nlm_version_header (abfd)->minorVersion =
|
||
get_word (abfd, (bfd_byte *) thdr.minorVersion);
|
||
nlm_version_header (abfd)->revision =
|
||
get_word (abfd, (bfd_byte *) thdr.revision);
|
||
nlm_version_header (abfd)->year =
|
||
get_word (abfd, (bfd_byte *) thdr.year);
|
||
nlm_version_header (abfd)->month =
|
||
get_word (abfd, (bfd_byte *) thdr.month);
|
||
nlm_version_header (abfd)->day =
|
||
get_word (abfd, (bfd_byte *) thdr.day);
|
||
}
|
||
else if (strncmp (tempstr, "MeSsAgEs", 8) == 0)
|
||
{
|
||
Nlm_External_Extended_Header thdr;
|
||
|
||
amt = sizeof (thdr);
|
||
if (bfd_bread ((PTR) &thdr, amt, abfd) != amt)
|
||
return FALSE;
|
||
memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp,
|
||
sizeof (thdr.stamp));
|
||
nlm_extended_header (abfd)->languageID =
|
||
get_word (abfd, (bfd_byte *) thdr.languageID);
|
||
nlm_extended_header (abfd)->messageFileOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.messageFileOffset);
|
||
nlm_extended_header (abfd)->messageFileLength =
|
||
get_word (abfd, (bfd_byte *) thdr.messageFileLength);
|
||
nlm_extended_header (abfd)->messageCount =
|
||
get_word (abfd, (bfd_byte *) thdr.messageCount);
|
||
nlm_extended_header (abfd)->helpFileOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.helpFileOffset);
|
||
nlm_extended_header (abfd)->helpFileLength =
|
||
get_word (abfd, (bfd_byte *) thdr.helpFileLength);
|
||
nlm_extended_header (abfd)->RPCDataOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.RPCDataOffset);
|
||
nlm_extended_header (abfd)->RPCDataLength =
|
||
get_word (abfd, (bfd_byte *) thdr.RPCDataLength);
|
||
nlm_extended_header (abfd)->sharedCodeOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedCodeOffset);
|
||
nlm_extended_header (abfd)->sharedCodeLength =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedCodeLength);
|
||
nlm_extended_header (abfd)->sharedDataOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedDataOffset);
|
||
nlm_extended_header (abfd)->sharedDataLength =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedDataLength);
|
||
nlm_extended_header (abfd)->sharedRelocationFixupOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupOffset);
|
||
nlm_extended_header (abfd)->sharedRelocationFixupCount =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupCount);
|
||
nlm_extended_header (abfd)->sharedExternalReferenceOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceOffset);
|
||
nlm_extended_header (abfd)->sharedExternalReferenceCount =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceCount);
|
||
nlm_extended_header (abfd)->sharedPublicsOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedPublicsOffset);
|
||
nlm_extended_header (abfd)->sharedPublicsCount =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedPublicsCount);
|
||
nlm_extended_header (abfd)->sharedDebugRecordOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordOffset);
|
||
nlm_extended_header (abfd)->sharedDebugRecordCount =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordCount);
|
||
nlm_extended_header (abfd)->SharedInitializationOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.sharedInitializationOffset);
|
||
nlm_extended_header (abfd)->SharedExitProcedureOffset =
|
||
get_word (abfd, (bfd_byte *) thdr.SharedExitProcedureOffset);
|
||
nlm_extended_header (abfd)->productID =
|
||
get_word (abfd, (bfd_byte *) thdr.productID);
|
||
nlm_extended_header (abfd)->reserved0 =
|
||
get_word (abfd, (bfd_byte *) thdr.reserved0);
|
||
nlm_extended_header (abfd)->reserved1 =
|
||
get_word (abfd, (bfd_byte *) thdr.reserved1);
|
||
nlm_extended_header (abfd)->reserved2 =
|
||
get_word (abfd, (bfd_byte *) thdr.reserved2);
|
||
nlm_extended_header (abfd)->reserved3 =
|
||
get_word (abfd, (bfd_byte *) thdr.reserved3);
|
||
nlm_extended_header (abfd)->reserved4 =
|
||
get_word (abfd, (bfd_byte *) thdr.reserved4);
|
||
nlm_extended_header (abfd)->reserved5 =
|
||
get_word (abfd, (bfd_byte *) thdr.reserved5);
|
||
}
|
||
else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
|
||
{
|
||
amt = sizeof (nlm_copyright_header (abfd)->stamp);
|
||
if (bfd_bread ((PTR) nlm_copyright_header (abfd)->stamp,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
if (bfd_bread ((PTR) &(nlm_copyright_header (abfd)
|
||
->copyrightMessageLength),
|
||
(bfd_size_type) 1, abfd) != 1)
|
||
return FALSE;
|
||
/* The copyright message is a variable length string. */
|
||
amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
|
||
if (bfd_bread ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
}
|
||
else if (strncmp (tempstr, "CuStHeAd", 8) == 0)
|
||
{
|
||
Nlm_External_Custom_Header thdr;
|
||
bfd_size_type hdrLength;
|
||
file_ptr dataOffset;
|
||
bfd_size_type dataLength;
|
||
char dataStamp[8];
|
||
PTR hdr;
|
||
|
||
/* Read the stamp ("CuStHeAd"). */
|
||
amt = sizeof (thdr.stamp);
|
||
if (bfd_bread ((PTR) thdr.stamp, amt, abfd) != amt)
|
||
return FALSE;
|
||
/* Read the length of this custom header. */
|
||
amt = sizeof (thdr.length);
|
||
if (bfd_bread ((PTR) thdr.length, amt, abfd) != amt)
|
||
return FALSE;
|
||
hdrLength = get_word (abfd, (bfd_byte *) thdr.length);
|
||
/* Read further fields if we have them. */
|
||
if (hdrLength < NLM_TARGET_LONG_SIZE)
|
||
dataOffset = 0;
|
||
else
|
||
{
|
||
amt = sizeof (thdr.dataOffset);
|
||
if (bfd_bread ((PTR) thdr.dataOffset, amt, abfd) != amt)
|
||
return FALSE;
|
||
dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
|
||
}
|
||
if (hdrLength < 2 * NLM_TARGET_LONG_SIZE)
|
||
dataLength = 0;
|
||
else
|
||
{
|
||
amt = sizeof (thdr.dataLength);
|
||
if (bfd_bread ((PTR) thdr.dataLength, amt, abfd) != amt)
|
||
return FALSE;
|
||
dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
|
||
}
|
||
if (hdrLength < 2 * NLM_TARGET_LONG_SIZE + 8)
|
||
memset (dataStamp, 0, sizeof (dataStamp));
|
||
else
|
||
{
|
||
amt = sizeof (dataStamp);
|
||
if (bfd_bread ((PTR) dataStamp, amt, abfd) != amt)
|
||
return FALSE;
|
||
}
|
||
|
||
/* Read the rest of the header, if any. */
|
||
if (hdrLength <= 2 * NLM_TARGET_LONG_SIZE + 8)
|
||
{
|
||
hdr = NULL;
|
||
hdrLength = 0;
|
||
}
|
||
else
|
||
{
|
||
hdrLength -= 2 * NLM_TARGET_LONG_SIZE + 8;
|
||
hdr = bfd_alloc (abfd, hdrLength);
|
||
if (hdr == NULL)
|
||
return FALSE;
|
||
if (bfd_bread (hdr, hdrLength, abfd) != hdrLength)
|
||
return FALSE;
|
||
}
|
||
|
||
/* If we have found a Cygnus header, process it. Otherwise,
|
||
just save the associated data without trying to interpret
|
||
it. */
|
||
if (strncmp (dataStamp, "CyGnUsEx", 8) == 0)
|
||
{
|
||
file_ptr pos;
|
||
bfd_byte *contents;
|
||
bfd_byte *p, *pend;
|
||
|
||
BFD_ASSERT (hdrLength == 0 && hdr == NULL);
|
||
|
||
pos = bfd_tell (abfd);
|
||
if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
|
||
return FALSE;
|
||
contents = (bfd_byte *) bfd_alloc (abfd, dataLength);
|
||
if (contents == NULL)
|
||
return FALSE;
|
||
if (bfd_bread (contents, dataLength, abfd) != dataLength)
|
||
return FALSE;
|
||
if (bfd_seek (abfd, pos, SEEK_SET) != 0)
|
||
return FALSE;
|
||
|
||
memcpy (nlm_cygnus_ext_header (abfd), "CyGnUsEx", 8);
|
||
nlm_cygnus_ext_header (abfd)->offset = dataOffset;
|
||
nlm_cygnus_ext_header (abfd)->length = dataLength;
|
||
|
||
/* This data this header points to provides a list of
|
||
the sections which were in the original object file
|
||
which was converted to become an NLM. We locate
|
||
those sections and add them to the BFD. Note that
|
||
this is likely to create a second .text, .data and
|
||
.bss section; retrieving the sections by name will
|
||
get the actual NLM sections, which is what we want to
|
||
happen. The sections from the original file, which
|
||
may be subsets of the NLM section, can only be found
|
||
using bfd_map_over_sections. */
|
||
p = contents;
|
||
pend = p + dataLength;
|
||
while (p < pend)
|
||
{
|
||
char *name;
|
||
size_t l;
|
||
file_ptr filepos;
|
||
bfd_size_type size;
|
||
asection *newsec;
|
||
|
||
/* The format of this information is
|
||
null terminated section name
|
||
zeroes to adjust to 4 byte boundary
|
||
4 byte section data file pointer
|
||
4 byte section size
|
||
*/
|
||
|
||
name = (char *) p;
|
||
l = strlen (name) + 1;
|
||
l = (l + 3) &~ (size_t) 3;
|
||
p += l;
|
||
filepos = H_GET_32 (abfd, p);
|
||
p += 4;
|
||
size = H_GET_32 (abfd, p);
|
||
p += 4;
|
||
|
||
newsec = bfd_make_section_anyway (abfd, name);
|
||
if (newsec == (asection *) NULL)
|
||
return FALSE;
|
||
newsec->size = size;
|
||
if (filepos != 0)
|
||
{
|
||
newsec->filepos = filepos;
|
||
newsec->flags |= SEC_HAS_CONTENTS;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
memcpy (nlm_custom_header (abfd)->stamp, thdr.stamp,
|
||
sizeof (thdr.stamp));
|
||
nlm_custom_header (abfd)->hdrLength = hdrLength;
|
||
nlm_custom_header (abfd)->dataOffset = dataOffset;
|
||
nlm_custom_header (abfd)->dataLength = dataLength;
|
||
memcpy (nlm_custom_header (abfd)->dataStamp, dataStamp,
|
||
sizeof (dataStamp));
|
||
nlm_custom_header (abfd)->hdr = hdr;
|
||
}
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/* Return whether there is a non-zero byte in a memory block. */
|
||
|
||
static bfd_boolean
|
||
find_nonzero (buf, size)
|
||
PTR buf;
|
||
size_t size;
|
||
{
|
||
char *p = (char *) buf;
|
||
|
||
while (size-- != 0)
|
||
if (*p++ != 0)
|
||
return TRUE;
|
||
return FALSE;
|
||
}
|
||
|
||
/* Swap out the contents of the auxiliary headers. We create those
|
||
auxiliary headers which have been set non-zero. We do not require
|
||
the caller to set up the stamp fields. */
|
||
|
||
static bfd_boolean
|
||
nlm_swap_auxiliary_headers_out (abfd)
|
||
bfd *abfd;
|
||
{
|
||
bfd_size_type amt;
|
||
|
||
/* Write out the version header if there is one. */
|
||
if (find_nonzero ((PTR) nlm_version_header (abfd),
|
||
sizeof (Nlm_Internal_Version_Header)))
|
||
{
|
||
Nlm_External_Version_Header thdr;
|
||
|
||
memcpy (thdr.stamp, "VeRsIoN#", 8);
|
||
put_word (abfd, (bfd_vma) nlm_version_header (abfd)->majorVersion,
|
||
(bfd_byte *) thdr.majorVersion);
|
||
put_word (abfd, (bfd_vma) nlm_version_header (abfd)->minorVersion,
|
||
(bfd_byte *) thdr.minorVersion);
|
||
put_word (abfd, (bfd_vma) nlm_version_header (abfd)->revision,
|
||
(bfd_byte *) thdr.revision);
|
||
put_word (abfd, (bfd_vma) nlm_version_header (abfd)->year,
|
||
(bfd_byte *) thdr.year);
|
||
put_word (abfd, (bfd_vma) nlm_version_header (abfd)->month,
|
||
(bfd_byte *) thdr.month);
|
||
put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
|
||
(bfd_byte *) thdr.day);
|
||
if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
|
||
!= sizeof (thdr))
|
||
return FALSE;
|
||
}
|
||
|
||
/* Note - the CoPyRiGhT tag is emitted before the MeSsAgEs
|
||
tag in order to make the NW4.x and NW5.x loaders happy. */
|
||
|
||
/* Write out the copyright header if there is one. */
|
||
if (find_nonzero ((PTR) nlm_copyright_header (abfd),
|
||
sizeof (Nlm_Internal_Copyright_Header)))
|
||
{
|
||
Nlm_External_Copyright_Header thdr;
|
||
|
||
memcpy (thdr.stamp, "CoPyRiGhT=", 10);
|
||
amt = sizeof (thdr.stamp);
|
||
if (bfd_bwrite ((PTR) thdr.stamp, amt, abfd) != amt)
|
||
return FALSE;
|
||
thdr.copyrightMessageLength[0] =
|
||
nlm_copyright_header (abfd)->copyrightMessageLength;
|
||
amt = 1;
|
||
if (bfd_bwrite ((PTR) thdr.copyrightMessageLength, amt, abfd) != amt)
|
||
return FALSE;
|
||
/* The copyright message is a variable length string. */
|
||
amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
|
||
if (bfd_bwrite ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
|
||
amt, abfd) != amt)
|
||
return FALSE;
|
||
}
|
||
|
||
/* Write out the extended header if there is one. */
|
||
if (find_nonzero ((PTR) nlm_extended_header (abfd),
|
||
sizeof (Nlm_Internal_Extended_Header)))
|
||
{
|
||
Nlm_External_Extended_Header thdr;
|
||
|
||
memcpy (thdr.stamp, "MeSsAgEs", 8);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->languageID,
|
||
(bfd_byte *) thdr.languageID);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->messageFileOffset,
|
||
(bfd_byte *) thdr.messageFileOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->messageFileLength,
|
||
(bfd_byte *) thdr.messageFileLength);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->messageCount,
|
||
(bfd_byte *) thdr.messageCount);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->helpFileOffset,
|
||
(bfd_byte *) thdr.helpFileOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->helpFileLength,
|
||
(bfd_byte *) thdr.helpFileLength);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->RPCDataOffset,
|
||
(bfd_byte *) thdr.RPCDataOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->RPCDataLength,
|
||
(bfd_byte *) thdr.RPCDataLength);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedCodeOffset,
|
||
(bfd_byte *) thdr.sharedCodeOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedCodeLength,
|
||
(bfd_byte *) thdr.sharedCodeLength);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedDataOffset,
|
||
(bfd_byte *) thdr.sharedDataOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedDataLength,
|
||
(bfd_byte *) thdr.sharedDataLength);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupOffset,
|
||
(bfd_byte *) thdr.sharedRelocationFixupOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupCount,
|
||
(bfd_byte *) thdr.sharedRelocationFixupCount);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceOffset,
|
||
(bfd_byte *) thdr.sharedExternalReferenceOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceCount,
|
||
(bfd_byte *) thdr.sharedExternalReferenceCount);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedPublicsOffset,
|
||
(bfd_byte *) thdr.sharedPublicsOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedPublicsCount,
|
||
(bfd_byte *) thdr.sharedPublicsCount);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordOffset,
|
||
(bfd_byte *) thdr.sharedDebugRecordOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordCount,
|
||
(bfd_byte *) thdr.sharedDebugRecordCount);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->SharedInitializationOffset,
|
||
(bfd_byte *) thdr.sharedInitializationOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->SharedExitProcedureOffset,
|
||
(bfd_byte *) thdr.SharedExitProcedureOffset);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->productID,
|
||
(bfd_byte *) thdr.productID);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->reserved0,
|
||
(bfd_byte *) thdr.reserved0);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->reserved1,
|
||
(bfd_byte *) thdr.reserved1);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->reserved2,
|
||
(bfd_byte *) thdr.reserved2);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->reserved3,
|
||
(bfd_byte *) thdr.reserved3);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->reserved4,
|
||
(bfd_byte *) thdr.reserved4);
|
||
put_word (abfd,
|
||
(bfd_vma) nlm_extended_header (abfd)->reserved5,
|
||
(bfd_byte *) thdr.reserved5);
|
||
if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
|
||
!= sizeof (thdr))
|
||
return FALSE;
|
||
}
|
||
|
||
/* Write out the custom header if there is one. */
|
||
if (find_nonzero ((PTR) nlm_custom_header (abfd),
|
||
sizeof (Nlm_Internal_Custom_Header)))
|
||
{
|
||
Nlm_External_Custom_Header thdr;
|
||
bfd_boolean ds;
|
||
bfd_size_type hdrLength;
|
||
|
||
ds = find_nonzero ((PTR) nlm_custom_header (abfd)->dataStamp,
|
||
sizeof (nlm_custom_header (abfd)->dataStamp));
|
||
memcpy (thdr.stamp, "CuStHeAd", 8);
|
||
hdrLength = (2 * NLM_TARGET_LONG_SIZE + (ds ? 8 : 0)
|
||
+ nlm_custom_header (abfd)->hdrLength);
|
||
put_word (abfd, hdrLength, thdr.length);
|
||
put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataOffset,
|
||
thdr.dataOffset);
|
||
put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataLength,
|
||
thdr.dataLength);
|
||
if (! ds)
|
||
{
|
||
BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
|
||
amt = sizeof (thdr) - sizeof (thdr.dataStamp);
|
||
if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
|
||
return FALSE;
|
||
}
|
||
else
|
||
{
|
||
memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
|
||
sizeof (thdr.dataStamp));
|
||
amt = sizeof (thdr);
|
||
if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
|
||
return FALSE;
|
||
amt = nlm_custom_header (abfd)->hdrLength;
|
||
if (bfd_bwrite (nlm_custom_header (abfd)->hdr, amt, abfd) != amt)
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
/* Write out the Cygnus debugging header if there is one. */
|
||
if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
|
||
sizeof (Nlm_Internal_Cygnus_Ext_Header)))
|
||
{
|
||
Nlm_External_Custom_Header thdr;
|
||
|
||
memcpy (thdr.stamp, "CuStHeAd", 8);
|
||
put_word (abfd, (bfd_vma) 2 * NLM_TARGET_LONG_SIZE + 8,
|
||
(bfd_byte *) thdr.length);
|
||
put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->offset,
|
||
(bfd_byte *) thdr.dataOffset);
|
||
put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->length,
|
||
(bfd_byte *) thdr.dataLength);
|
||
memcpy (thdr.dataStamp, "CyGnUsEx", 8);
|
||
amt = sizeof (thdr);
|
||
if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/* We read the NLM's public symbols and use it to generate a bfd symbol
|
||
table (hey, it's better than nothing) on a one-for-one basis. Thus
|
||
use the number of public symbols as the number of bfd symbols we will
|
||
have once we actually get around to reading them in.
|
||
|
||
Return the number of bytes required to hold the symtab vector, based on
|
||
the count plus 1, since we will NULL terminate the vector allocated based
|
||
on this size. */
|
||
|
||
long
|
||
nlm_get_symtab_upper_bound (abfd)
|
||
bfd *abfd;
|
||
{
|
||
Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form. */
|
||
long symcount;
|
||
long symtab_size = 0;
|
||
|
||
i_fxdhdrp = nlm_fixed_header (abfd);
|
||
symcount = (i_fxdhdrp->numberOfPublics
|
||
+ i_fxdhdrp->numberOfDebugRecords
|
||
+ i_fxdhdrp->numberOfExternalReferences);
|
||
symtab_size = (symcount + 1) * (sizeof (asymbol));
|
||
return (symtab_size);
|
||
}
|
||
|
||
/* Note that bfd_get_symcount is guaranteed to be zero if slurping the
|
||
symbol table fails. */
|
||
|
||
long
|
||
nlm_canonicalize_symtab (abfd, alocation)
|
||
bfd *abfd;
|
||
asymbol **alocation;
|
||
{
|
||
nlm_symbol_type *symbase;
|
||
bfd_size_type counter = 0;
|
||
|
||
if (! nlm_slurp_symbol_table (abfd))
|
||
return -1;
|
||
symbase = nlm_get_symbols (abfd);
|
||
while (counter < bfd_get_symcount (abfd))
|
||
{
|
||
*alocation++ = &symbase->symbol;
|
||
symbase++;
|
||
counter++;
|
||
}
|
||
*alocation = (asymbol *) NULL;
|
||
return bfd_get_symcount (abfd);
|
||
}
|
||
|
||
/* Make an NLM symbol. There is nothing special to do here. */
|
||
|
||
asymbol *
|
||
nlm_make_empty_symbol (abfd)
|
||
bfd *abfd;
|
||
{
|
||
bfd_size_type amt = sizeof (nlm_symbol_type);
|
||
nlm_symbol_type *new = (nlm_symbol_type *) bfd_zalloc (abfd, amt);
|
||
|
||
if (new)
|
||
new->symbol.the_bfd = abfd;
|
||
return &new->symbol;
|
||
}
|
||
|
||
/* Get symbol information. */
|
||
|
||
void
|
||
nlm_get_symbol_info (ignore_abfd, symbol, ret)
|
||
bfd *ignore_abfd ATTRIBUTE_UNUSED;
|
||
asymbol *symbol;
|
||
symbol_info *ret;
|
||
{
|
||
bfd_symbol_info (symbol, ret);
|
||
}
|
||
|
||
/* Print symbol information. */
|
||
|
||
void
|
||
nlm_print_symbol (abfd, afile, symbol, how)
|
||
bfd *abfd;
|
||
PTR afile;
|
||
asymbol *symbol;
|
||
bfd_print_symbol_type how;
|
||
{
|
||
FILE *file = (FILE *) afile;
|
||
|
||
switch (how)
|
||
{
|
||
case bfd_print_symbol_name:
|
||
case bfd_print_symbol_more:
|
||
if (symbol->name)
|
||
fprintf (file, "%s", symbol->name);
|
||
break;
|
||
case bfd_print_symbol_all:
|
||
bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
|
||
fprintf (file, " %-5s", symbol->section->name);
|
||
if (symbol->name)
|
||
fprintf (file, " %s", symbol->name);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Slurp in nlm symbol table.
|
||
|
||
In the external (in-file) form, NLM export records are variable length,
|
||
with the following form:
|
||
|
||
1 byte length of the symbol name (N)
|
||
N bytes the symbol name
|
||
4 bytes the symbol offset from start of it's section
|
||
|
||
We also read in the debugging symbols and import records. Import
|
||
records are treated as undefined symbols. As we read the import
|
||
records we also read in the associated reloc information, which is
|
||
attached to the symbol.
|
||
|
||
The bfd symbols are copied to SYMPTRS.
|
||
|
||
When we return, the bfd symcount is either zero or contains the correct
|
||
number of symbols. */
|
||
|
||
static bfd_boolean
|
||
nlm_slurp_symbol_table (abfd)
|
||
bfd *abfd;
|
||
{
|
||
Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form. */
|
||
bfd_size_type totsymcount; /* Number of NLM symbols. */
|
||
bfd_size_type symcount; /* Counter of NLM symbols. */
|
||
nlm_symbol_type *sym; /* Pointer to current bfd symbol. */
|
||
unsigned char symlength; /* Symbol length read into here. */
|
||
unsigned char symtype; /* Type of debugging symbol. */
|
||
bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Symbol offsets read into here. */
|
||
bfd_boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *));
|
||
bfd_boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
|
||
bfd_size_type amt;
|
||
|
||
if (nlm_get_symbols (abfd) != NULL)
|
||
return TRUE;
|
||
|
||
/* Read each raw NLM symbol, using the information to create a canonical bfd
|
||
symbol table entry.
|
||
|
||
Note that we allocate the initial bfd canonical symbol buffer based on a
|
||
one-to-one mapping of the NLM symbols to canonical symbols. We actually
|
||
use all the NLM symbols, so there will be no space left over at the end.
|
||
When we have all the symbols, we build the caller's pointer vector. */
|
||
|
||
abfd->symcount = 0;
|
||
i_fxdhdrp = nlm_fixed_header (abfd);
|
||
totsymcount = (i_fxdhdrp->numberOfPublics
|
||
+ i_fxdhdrp->numberOfDebugRecords
|
||
+ i_fxdhdrp->numberOfExternalReferences);
|
||
if (totsymcount == 0)
|
||
return TRUE;
|
||
|
||
if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) != 0)
|
||
return FALSE;
|
||
|
||
amt = totsymcount * sizeof (nlm_symbol_type);
|
||
sym = ((nlm_symbol_type *) bfd_zalloc (abfd, amt));
|
||
if (!sym)
|
||
return FALSE;
|
||
nlm_set_symbols (abfd, sym);
|
||
|
||
/* We use the bfd's symcount directly as the control count, so that early
|
||
termination of the loop leaves the symcount correct for the symbols that
|
||
were read. */
|
||
|
||
set_public_section_func = nlm_set_public_section_func (abfd);
|
||
symcount = i_fxdhdrp->numberOfPublics;
|
||
while (abfd->symcount < symcount)
|
||
{
|
||
amt = sizeof (symlength);
|
||
if (bfd_bread ((PTR) &symlength, amt, abfd) != amt)
|
||
return FALSE;
|
||
amt = symlength;
|
||
sym->symbol.the_bfd = abfd;
|
||
sym->symbol.name = bfd_alloc (abfd, amt + 1);
|
||
if (!sym->symbol.name)
|
||
return FALSE;
|
||
if (bfd_bread ((PTR) sym->symbol.name, amt, abfd) != amt)
|
||
return FALSE;
|
||
/* Cast away const. */
|
||
((char *) (sym->symbol.name))[symlength] = '\0';
|
||
amt = sizeof (temp);
|
||
if (bfd_bread ((PTR) temp, amt, abfd) != amt)
|
||
return FALSE;
|
||
sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
|
||
sym->symbol.value = get_word (abfd, temp);
|
||
if (set_public_section_func)
|
||
{
|
||
/* Most backends can use the code below, but unfortunately
|
||
some use a different scheme. */
|
||
if (! (*set_public_section_func) (abfd, sym))
|
||
return FALSE;
|
||
}
|
||
else
|
||
{
|
||
if (sym->symbol.value & NLM_HIBIT)
|
||
{
|
||
sym->symbol.value &= ~NLM_HIBIT;
|
||
sym->symbol.flags |= BSF_FUNCTION;
|
||
sym->symbol.section =
|
||
bfd_get_section_by_name (abfd, NLM_CODE_NAME);
|
||
}
|
||
else
|
||
{
|
||
sym->symbol.section =
|
||
bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
|
||
}
|
||
}
|
||
sym->rcnt = 0;
|
||
abfd->symcount++;
|
||
sym++;
|
||
}
|
||
|
||
/* Read the debugging records. */
|
||
|
||
if (i_fxdhdrp->numberOfDebugRecords > 0)
|
||
{
|
||
if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) != 0)
|
||
return FALSE;
|
||
|
||
symcount += i_fxdhdrp->numberOfDebugRecords;
|
||
while (abfd->symcount < symcount)
|
||
{
|
||
amt = sizeof (symtype);
|
||
if (bfd_bread ((PTR) &symtype, amt, abfd) != amt)
|
||
return FALSE;
|
||
amt = sizeof (temp);
|
||
if (bfd_bread ((PTR) temp, amt, abfd) != amt)
|
||
return FALSE;
|
||
amt = sizeof (symlength);
|
||
if (bfd_bread ((PTR) &symlength, amt, abfd) != amt)
|
||
return FALSE;
|
||
amt = symlength;
|
||
sym->symbol.the_bfd = abfd;
|
||
sym->symbol.name = bfd_alloc (abfd, amt + 1);
|
||
if (!sym->symbol.name)
|
||
return FALSE;
|
||
if (bfd_bread ((PTR) sym->symbol.name, amt, abfd) != amt)
|
||
return FALSE;
|
||
/* Cast away const. */
|
||
((char *) (sym->symbol.name))[symlength] = '\0';
|
||
sym->symbol.flags = BSF_LOCAL;
|
||
sym->symbol.value = get_word (abfd, temp);
|
||
if (symtype == 0)
|
||
{
|
||
sym->symbol.section =
|
||
bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
|
||
}
|
||
else if (symtype == 1)
|
||
{
|
||
sym->symbol.flags |= BSF_FUNCTION;
|
||
sym->symbol.section =
|
||
bfd_get_section_by_name (abfd, NLM_CODE_NAME);
|
||
}
|
||
else
|
||
{
|
||
sym->symbol.section = bfd_abs_section_ptr;
|
||
}
|
||
sym->rcnt = 0;
|
||
abfd->symcount++;
|
||
sym++;
|
||
}
|
||
}
|
||
|
||
/* Read in the import records. We can only do this if we know how
|
||
to read relocs for this target. */
|
||
read_import_func = nlm_read_import_func (abfd);
|
||
if (read_import_func != NULL)
|
||
{
|
||
if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET) != 0)
|
||
return FALSE;
|
||
|
||
symcount += i_fxdhdrp->numberOfExternalReferences;
|
||
while (abfd->symcount < symcount)
|
||
{
|
||
if (! (*read_import_func) (abfd, sym))
|
||
return FALSE;
|
||
sym++;
|
||
abfd->symcount++;
|
||
}
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/* Get the relocs for an NLM file. There are two types of relocs.
|
||
Imports are relocs against symbols defined in other NLM files. We
|
||
treat these as relocs against global symbols. Relocation fixups
|
||
are internal relocs.
|
||
|
||
The actual format used to store the relocs is machine specific. */
|
||
|
||
/* Read in the relocation fixup information. This is stored in
|
||
nlm_relocation_fixups, an array of arelent structures, and
|
||
nlm_relocation_fixup_secs, an array of section pointers. The
|
||
section pointers are needed because the relocs are not sorted by
|
||
section. */
|
||
|
||
static bfd_boolean
|
||
nlm_slurp_reloc_fixups (abfd)
|
||
bfd *abfd;
|
||
{
|
||
bfd_boolean (*read_func)
|
||
PARAMS ((bfd *, nlm_symbol_type *, asection **, arelent *));
|
||
bfd_size_type count, amt;
|
||
arelent *rels;
|
||
asection **secs;
|
||
|
||
if (nlm_relocation_fixups (abfd) != NULL)
|
||
return TRUE;
|
||
read_func = nlm_read_reloc_func (abfd);
|
||
if (read_func == NULL)
|
||
return TRUE;
|
||
|
||
if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
|
||
SEEK_SET) != 0)
|
||
return FALSE;
|
||
|
||
count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
|
||
amt = count * sizeof (arelent);
|
||
rels = (arelent *) bfd_alloc (abfd, amt);
|
||
amt = count * sizeof (asection *);
|
||
secs = (asection **) bfd_alloc (abfd, amt);
|
||
if ((rels == NULL || secs == NULL) && count != 0)
|
||
return FALSE;
|
||
nlm_relocation_fixups (abfd) = rels;
|
||
nlm_relocation_fixup_secs (abfd) = secs;
|
||
|
||
/* We have to read piece by piece, because we don't know how large
|
||
the machine specific reloc information is. */
|
||
while (count-- != 0)
|
||
{
|
||
if (! (*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels))
|
||
{
|
||
nlm_relocation_fixups (abfd) = NULL;
|
||
nlm_relocation_fixup_secs (abfd) = NULL;
|
||
return FALSE;
|
||
}
|
||
++secs;
|
||
++rels;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/* Get the number of relocs. This really just returns an upper bound,
|
||
since it does not attempt to distinguish them based on the section.
|
||
That will be handled when they are actually read. */
|
||
|
||
long
|
||
nlm_get_reloc_upper_bound (abfd, sec)
|
||
bfd *abfd;
|
||
asection *sec;
|
||
{
|
||
nlm_symbol_type *syms;
|
||
bfd_size_type count;
|
||
unsigned int ret;
|
||
|
||
/* If we don't know how to read relocs, just return 0. */
|
||
if (nlm_read_reloc_func (abfd) == NULL)
|
||
return -1;
|
||
/* Make sure we have either the code or the data section. */
|
||
if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
|
||
return 0;
|
||
|
||
syms = nlm_get_symbols (abfd);
|
||
if (syms == NULL)
|
||
{
|
||
if (! nlm_slurp_symbol_table (abfd))
|
||
return -1;
|
||
syms = nlm_get_symbols (abfd);
|
||
}
|
||
|
||
ret = nlm_fixed_header (abfd)->numberOfRelocationFixups;
|
||
|
||
count = bfd_get_symcount (abfd);
|
||
while (count-- != 0)
|
||
{
|
||
ret += syms->rcnt;
|
||
++syms;
|
||
}
|
||
|
||
return (ret + 1) * sizeof (arelent *);
|
||
}
|
||
|
||
/* Get the relocs themselves. */
|
||
|
||
long
|
||
nlm_canonicalize_reloc (abfd, sec, relptr, symbols)
|
||
bfd *abfd;
|
||
asection *sec;
|
||
arelent **relptr;
|
||
asymbol **symbols;
|
||
{
|
||
arelent *rels;
|
||
asection **secs;
|
||
bfd_size_type count, i;
|
||
unsigned int ret;
|
||
|
||
/* Get the relocation fixups. */
|
||
rels = nlm_relocation_fixups (abfd);
|
||
if (rels == NULL)
|
||
{
|
||
if (! nlm_slurp_reloc_fixups (abfd))
|
||
return -1;
|
||
rels = nlm_relocation_fixups (abfd);
|
||
}
|
||
secs = nlm_relocation_fixup_secs (abfd);
|
||
|
||
ret = 0;
|
||
count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
|
||
for (i = 0; i < count; i++, rels++, secs++)
|
||
{
|
||
if (*secs == sec)
|
||
{
|
||
*relptr++ = rels;
|
||
++ret;
|
||
}
|
||
}
|
||
|
||
/* Get the import symbols. */
|
||
count = bfd_get_symcount (abfd);
|
||
for (i = 0; i < count; i++, symbols++)
|
||
{
|
||
asymbol *sym;
|
||
|
||
sym = *symbols;
|
||
if (bfd_asymbol_flavour (sym) == bfd_target_nlm_flavour)
|
||
{
|
||
nlm_symbol_type *nlm_sym;
|
||
bfd_size_type j;
|
||
|
||
nlm_sym = (nlm_symbol_type *) sym;
|
||
for (j = 0; j < nlm_sym->rcnt; j++)
|
||
{
|
||
if (nlm_sym->relocs[j].section == sec)
|
||
{
|
||
*relptr = &nlm_sym->relocs[j].reloc;
|
||
(*relptr)->sym_ptr_ptr = symbols;
|
||
++relptr;
|
||
++ret;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
*relptr = NULL;
|
||
|
||
return ret;
|
||
}
|
||
|
||
/* Compute the section file positions for an NLM file. All variable
|
||
length data in the file headers must be set before this function is
|
||
called. If the variable length data is changed later, the
|
||
resulting object file will be incorrect. Unfortunately, there is
|
||
no way to check this.
|
||
|
||
This routine also sets the Size and Offset fields in the fixed
|
||
header.
|
||
|
||
It also looks over the symbols and moves any common symbols into
|
||
the .bss section; NLM has no way to represent a common symbol.
|
||
This approach means that either the symbols must already have been
|
||
set at this point, or there must be no common symbols. We need to
|
||
move the symbols at this point so that mangle_relocs can see the
|
||
final values. */
|
||
|
||
static bfd_boolean
|
||
nlm_compute_section_file_positions (abfd)
|
||
bfd *abfd;
|
||
{
|
||
file_ptr sofar;
|
||
asection *sec;
|
||
bfd_vma text, data, bss;
|
||
bfd_vma text_low, data_low;
|
||
unsigned int text_align, data_align, other_align;
|
||
file_ptr text_ptr, data_ptr, other_ptr;
|
||
asection *bss_sec;
|
||
asymbol **sym_ptr_ptr;
|
||
|
||
if (abfd->output_has_begun)
|
||
return TRUE;
|
||
|
||
/* Make sure we have a section to hold uninitialized data. */
|
||
bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
|
||
if (bss_sec == NULL)
|
||
{
|
||
if (!add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
|
||
(file_ptr) 0, (bfd_size_type) 0,
|
||
SEC_ALLOC))
|
||
return FALSE;
|
||
bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
|
||
}
|
||
|
||
abfd->output_has_begun = TRUE;
|
||
|
||
/* The fixed header. */
|
||
sofar = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
|
||
|
||
/* The variable header. */
|
||
sofar += (sizeof (nlm_variable_header (abfd)->descriptionLength)
|
||
+ nlm_variable_header (abfd)->descriptionLength + 1
|
||
+ NLM_TARGET_LONG_SIZE /* stackSize */
|
||
+ NLM_TARGET_LONG_SIZE /* reserved */
|
||
+ sizeof (nlm_variable_header (abfd)->oldThreadName)
|
||
+ sizeof (nlm_variable_header (abfd)->screenNameLength)
|
||
+ nlm_variable_header (abfd)->screenNameLength + 1
|
||
+ sizeof (nlm_variable_header (abfd)->threadNameLength)
|
||
+ nlm_variable_header (abfd)->threadNameLength + 1);
|
||
|
||
/* The auxiliary headers. */
|
||
if (find_nonzero ((PTR) nlm_version_header (abfd),
|
||
sizeof (Nlm_Internal_Version_Header)))
|
||
sofar += sizeof (Nlm_External_Version_Header);
|
||
if (find_nonzero ((PTR) nlm_extended_header (abfd),
|
||
sizeof (Nlm_Internal_Extended_Header)))
|
||
sofar += sizeof (Nlm_External_Extended_Header);
|
||
if (find_nonzero ((PTR) nlm_copyright_header (abfd),
|
||
sizeof (Nlm_Internal_Copyright_Header)))
|
||
sofar += (sizeof (Nlm_External_Copyright_Header)
|
||
+ nlm_copyright_header (abfd)->copyrightMessageLength + 1);
|
||
if (find_nonzero ((PTR) nlm_custom_header (abfd),
|
||
sizeof (Nlm_Internal_Custom_Header)))
|
||
sofar += (sizeof (Nlm_External_Custom_Header)
|
||
+ nlm_custom_header (abfd)->hdrLength);
|
||
if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
|
||
sizeof (Nlm_Internal_Cygnus_Ext_Header)))
|
||
sofar += sizeof (Nlm_External_Custom_Header);
|
||
|
||
/* Compute the section file positions in two passes. First get the
|
||
sizes of the text and data sections, and then set the file
|
||
positions. This code aligns the sections in the file using the
|
||
same alignment restrictions that apply to the sections in memory;
|
||
this may not be necessary. */
|
||
text = 0;
|
||
text_low = (bfd_vma) - 1;
|
||
text_align = 0;
|
||
data = 0;
|
||
data_low = (bfd_vma) - 1;
|
||
data_align = 0;
|
||
bss = 0;
|
||
other_align = 0;
|
||
for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
|
||
{
|
||
flagword f;
|
||
|
||
sec->size = BFD_ALIGN (sec->size, 1 << sec->alignment_power);
|
||
|
||
f = bfd_get_section_flags (abfd, sec);
|
||
if (f & SEC_CODE)
|
||
{
|
||
text += sec->size;
|
||
if (bfd_get_section_vma (abfd, sec) < text_low)
|
||
text_low = bfd_get_section_vma (abfd, sec);
|
||
if (sec->alignment_power > text_align)
|
||
text_align = sec->alignment_power;
|
||
}
|
||
else if (f & SEC_DATA)
|
||
{
|
||
data += sec->size;
|
||
if (bfd_get_section_vma (abfd, sec) < data_low)
|
||
data_low = bfd_get_section_vma (abfd, sec);
|
||
if (sec->alignment_power > data_align)
|
||
data_align = sec->alignment_power;
|
||
}
|
||
else if (f & SEC_HAS_CONTENTS)
|
||
{
|
||
if (sec->alignment_power > other_align)
|
||
other_align = sec->alignment_power;
|
||
}
|
||
else if (f & SEC_ALLOC)
|
||
bss += sec->size;
|
||
}
|
||
|
||
nlm_set_text_low (abfd, text_low);
|
||
nlm_set_data_low (abfd, data_low);
|
||
|
||
if (nlm_no_uninitialized_data (abfd))
|
||
{
|
||
/* This NetWare format does not use uninitialized data. We must
|
||
increase the size of the data section. We will never wind up
|
||
writing those file locations, so they will remain zero. */
|
||
data += bss;
|
||
bss = 0;
|
||
}
|
||
|
||
text_ptr = BFD_ALIGN (sofar, 1 << text_align);
|
||
data_ptr = BFD_ALIGN (text_ptr + text, 1 << data_align);
|
||
other_ptr = BFD_ALIGN (data_ptr + data, 1 << other_align);
|
||
|
||
/* Fill in some fields in the header for which we now have the
|
||
information. */
|
||
nlm_fixed_header (abfd)->codeImageOffset = text_ptr;
|
||
nlm_fixed_header (abfd)->codeImageSize = text;
|
||
nlm_fixed_header (abfd)->dataImageOffset = data_ptr;
|
||
nlm_fixed_header (abfd)->dataImageSize = data;
|
||
nlm_fixed_header (abfd)->uninitializedDataSize = bss;
|
||
|
||
for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
|
||
{
|
||
flagword f;
|
||
|
||
f = bfd_get_section_flags (abfd, sec);
|
||
|
||
if (f & SEC_CODE)
|
||
{
|
||
sec->filepos = text_ptr;
|
||
text_ptr += sec->size;
|
||
}
|
||
else if (f & SEC_DATA)
|
||
{
|
||
sec->filepos = data_ptr;
|
||
data_ptr += sec->size;
|
||
}
|
||
else if (f & SEC_HAS_CONTENTS)
|
||
{
|
||
sec->filepos = other_ptr;
|
||
other_ptr += sec->size;
|
||
}
|
||
}
|
||
|
||
nlm_fixed_header (abfd)->relocationFixupOffset = other_ptr;
|
||
|
||
/* Move all common symbols into the .bss section. */
|
||
|
||
sym_ptr_ptr = bfd_get_outsymbols (abfd);
|
||
if (sym_ptr_ptr != NULL)
|
||
{
|
||
asymbol **sym_end;
|
||
bfd_vma add;
|
||
|
||
sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
|
||
add = 0;
|
||
for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
|
||
{
|
||
asymbol *sym;
|
||
bfd_vma size;
|
||
|
||
sym = *sym_ptr_ptr;
|
||
|
||
if (!bfd_is_com_section (bfd_get_section (sym)))
|
||
continue;
|
||
|
||
/* Put the common symbol in the .bss section, and increase
|
||
the size of the .bss section by the size of the common
|
||
symbol (which is the old value of the symbol). */
|
||
sym->section = bss_sec;
|
||
size = sym->value;
|
||
sym->value = bss_sec->size + add;
|
||
add += size;
|
||
add = BFD_ALIGN (add, 1 << bss_sec->alignment_power);
|
||
}
|
||
if (add != 0)
|
||
{
|
||
if (nlm_no_uninitialized_data (abfd))
|
||
{
|
||
/* We could handle this case, but so far it hasn't been
|
||
necessary. */
|
||
abort ();
|
||
}
|
||
nlm_fixed_header (abfd)->uninitializedDataSize += add;
|
||
bss_sec->size += add;
|
||
}
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/* Set the contents of a section. To do this we need to know where
|
||
the section is going to be located in the output file. That means
|
||
that the sizes of all the sections must be set, and all the
|
||
variable size header information must be known. */
|
||
|
||
bfd_boolean
|
||
nlm_set_section_contents (abfd, section, location, offset, count)
|
||
bfd *abfd;
|
||
asection *section;
|
||
const PTR location;
|
||
file_ptr offset;
|
||
bfd_size_type count;
|
||
{
|
||
if (! abfd->output_has_begun
|
||
&& ! nlm_compute_section_file_positions (abfd))
|
||
return FALSE;
|
||
|
||
if (count == 0)
|
||
return TRUE;
|
||
|
||
/* i386 NetWare has a very restricted set of relocs. In order for
|
||
objcopy to work, the NLM i386 backend needs a chance to rework
|
||
the section contents so that its set of relocs will work. If all
|
||
the relocs are already acceptable, this will not do anything. */
|
||
if (section->reloc_count != 0)
|
||
{
|
||
bfd_boolean (*mangle_relocs_func)
|
||
PARAMS ((bfd *, asection *, const PTR, bfd_vma, bfd_size_type));
|
||
|
||
mangle_relocs_func = nlm_mangle_relocs_func (abfd);
|
||
if (mangle_relocs_func != NULL)
|
||
{
|
||
if (!(*mangle_relocs_func) (abfd, section, location,
|
||
(bfd_vma) offset, count))
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
|
||
|| bfd_bwrite (location, count, abfd) != count)
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/* We need to sort a list of relocs associated with sections when we
|
||
write out the external relocs. */
|
||
|
||
static int
|
||
nlm_external_reloc_compare (p1, p2)
|
||
const void *p1;
|
||
const void *p2;
|
||
{
|
||
const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1;
|
||
const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2;
|
||
int cmp;
|
||
|
||
cmp = strcmp ((*r1->rel->sym_ptr_ptr)->name,
|
||
(*r2->rel->sym_ptr_ptr)->name);
|
||
if (cmp != 0)
|
||
return cmp;
|
||
|
||
/* We sort by address within symbol to make the sort more stable and
|
||
increase the chances that different hosts will generate bit for
|
||
bit equivalent results. */
|
||
return (int) (r1->rel->address - r2->rel->address);
|
||
}
|
||
|
||
/* Write out an NLM file. We write out the information in this order:
|
||
fixed header
|
||
variable header
|
||
auxiliary headers
|
||
code sections
|
||
data sections
|
||
other sections (custom data, messages, help, shared NLM, RPC,
|
||
module dependencies)
|
||
relocation fixups
|
||
external references (imports)
|
||
public symbols (exports)
|
||
debugging records
|
||
This is similar to the order used by the NetWare tools; the
|
||
difference is that NetWare puts the sections other than code, data
|
||
and custom data at the end of the NLM. It is convenient for us to
|
||
know where the sections are going to be before worrying about the
|
||
size of the other information.
|
||
|
||
By the time this function is called, all the section data should
|
||
have been output using set_section_contents. Note that custom
|
||
data, the message file, the help file, the shared NLM file, the RPC
|
||
data, and the module dependencies are all considered to be
|
||
sections; the caller is responsible for filling in the offset and
|
||
length fields in the NLM headers. The relocation fixups and
|
||
imports are both obtained from the list of relocs attached to each
|
||
section. The exports and debugging records are obtained from the
|
||
list of outsymbols. */
|
||
|
||
bfd_boolean
|
||
nlm_write_object_contents (abfd)
|
||
bfd *abfd;
|
||
{
|
||
asection *sec;
|
||
bfd_boolean (*write_import_func) PARAMS ((bfd *, asection *, arelent *));
|
||
bfd_size_type external_reloc_count, internal_reloc_count, i, c;
|
||
struct reloc_and_sec *external_relocs;
|
||
asymbol **sym_ptr_ptr;
|
||
file_ptr last;
|
||
bfd_boolean (*write_prefix_func) PARAMS ((bfd *));
|
||
unsigned char *fixed_header = NULL;
|
||
file_ptr pos;
|
||
bfd_size_type amt;
|
||
|
||
fixed_header = ((unsigned char *)
|
||
bfd_malloc (nlm_fixed_header_size (abfd)));
|
||
if (fixed_header == NULL)
|
||
goto error_return;
|
||
|
||
if (! abfd->output_has_begun
|
||
&& ! nlm_compute_section_file_positions (abfd))
|
||
goto error_return;
|
||
|
||
/* Write out the variable length headers. */
|
||
pos = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
|
||
if (bfd_seek (abfd, pos, SEEK_SET) != 0)
|
||
goto error_return;
|
||
if (! nlm_swap_variable_header_out (abfd)
|
||
|| ! nlm_swap_auxiliary_headers_out (abfd))
|
||
{
|
||
bfd_set_error (bfd_error_system_call);
|
||
goto error_return;
|
||
}
|
||
|
||
/* A weak check on whether the section file positions were
|
||
reasonable. */
|
||
if (bfd_tell (abfd) > (ufile_ptr) nlm_fixed_header (abfd)->codeImageOffset)
|
||
{
|
||
bfd_set_error (bfd_error_invalid_operation);
|
||
goto error_return;
|
||
}
|
||
|
||
/* Advance to the relocs. */
|
||
if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
|
||
SEEK_SET) != 0)
|
||
goto error_return;
|
||
|
||
/* The format of the relocation entries is dependent upon the
|
||
particular target. We use an external routine to write the reloc
|
||
out. */
|
||
write_import_func = nlm_write_import_func (abfd);
|
||
|
||
/* Write out the internal relocation fixups. While we're looping
|
||
over the relocs, we also count the external relocs, which is
|
||
needed when they are written out below. */
|
||
internal_reloc_count = 0;
|
||
external_reloc_count = 0;
|
||
for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
|
||
{
|
||
arelent **rel_ptr_ptr, **rel_end;
|
||
|
||
if (sec->reloc_count == 0)
|
||
continue;
|
||
|
||
/* We can only represent relocs within a code or data
|
||
section. We ignore them for a debugging section. */
|
||
if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
|
||
continue;
|
||
|
||
/* We need to know how to write out imports */
|
||
if (write_import_func == NULL)
|
||
{
|
||
bfd_set_error (bfd_error_invalid_operation);
|
||
goto error_return;
|
||
}
|
||
|
||
rel_ptr_ptr = sec->orelocation;
|
||
rel_end = rel_ptr_ptr + sec->reloc_count;
|
||
for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
|
||
{
|
||
arelent *rel;
|
||
asymbol *sym;
|
||
|
||
rel = *rel_ptr_ptr;
|
||
sym = *rel->sym_ptr_ptr;
|
||
|
||
if (! bfd_is_und_section (bfd_get_section (sym)))
|
||
{
|
||
++internal_reloc_count;
|
||
if (! (*write_import_func) (abfd, sec, rel))
|
||
goto error_return;
|
||
}
|
||
else
|
||
++external_reloc_count;
|
||
}
|
||
}
|
||
nlm_fixed_header (abfd)->numberOfRelocationFixups = internal_reloc_count;
|
||
|
||
/* Write out the imports (relocs against external symbols). These
|
||
are output as a symbol name followed by all the relocs for that
|
||
symbol, so we must first gather together all the relocs against
|
||
external symbols and sort them. */
|
||
amt = external_reloc_count * sizeof (struct reloc_and_sec);
|
||
external_relocs = (struct reloc_and_sec *) bfd_alloc (abfd, amt);
|
||
if (external_relocs == (struct reloc_and_sec *) NULL)
|
||
goto error_return;
|
||
i = 0;
|
||
for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
|
||
{
|
||
arelent **rel_ptr_ptr, **rel_end;
|
||
|
||
if (sec->reloc_count == 0)
|
||
continue;
|
||
|
||
rel_ptr_ptr = sec->orelocation;
|
||
rel_end = rel_ptr_ptr + sec->reloc_count;
|
||
for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
|
||
{
|
||
arelent *rel;
|
||
asymbol *sym;
|
||
|
||
rel = *rel_ptr_ptr;
|
||
sym = *rel->sym_ptr_ptr;
|
||
|
||
if (! bfd_is_und_section (bfd_get_section (sym)))
|
||
continue;
|
||
|
||
external_relocs[i].rel = rel;
|
||
external_relocs[i].sec = sec;
|
||
++i;
|
||
}
|
||
}
|
||
|
||
BFD_ASSERT (i == external_reloc_count);
|
||
|
||
/* Sort the external relocs by name. */
|
||
qsort ((PTR) external_relocs, (size_t) external_reloc_count,
|
||
sizeof (struct reloc_and_sec), nlm_external_reloc_compare);
|
||
|
||
/* Write out the external relocs. */
|
||
nlm_fixed_header (abfd)->externalReferencesOffset = bfd_tell (abfd);
|
||
c = 0;
|
||
i = 0;
|
||
while (i < external_reloc_count)
|
||
{
|
||
arelent *rel;
|
||
asymbol *sym;
|
||
bfd_size_type j, cnt;
|
||
|
||
++c;
|
||
|
||
rel = external_relocs[i].rel;
|
||
sym = *rel->sym_ptr_ptr;
|
||
|
||
cnt = 0;
|
||
for (j = i;
|
||
(j < external_reloc_count
|
||
&& *external_relocs[j].rel->sym_ptr_ptr == sym);
|
||
j++)
|
||
++cnt;
|
||
|
||
if (! (*nlm_write_external_func (abfd)) (abfd, cnt, sym,
|
||
&external_relocs[i]))
|
||
goto error_return;
|
||
|
||
i += cnt;
|
||
}
|
||
|
||
nlm_fixed_header (abfd)->numberOfExternalReferences = c;
|
||
|
||
/* Write out the public symbols (exports). */
|
||
sym_ptr_ptr = bfd_get_outsymbols (abfd);
|
||
if (sym_ptr_ptr != (asymbol **) NULL)
|
||
{
|
||
bfd_vma (*get_public_offset_func) PARAMS ((bfd *, asymbol *));
|
||
bfd_boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
|
||
|
||
asymbol **sym_end;
|
||
|
||
nlm_fixed_header (abfd)->publicsOffset = bfd_tell (abfd);
|
||
get_public_offset_func = nlm_get_public_offset_func (abfd);
|
||
write_export_func = nlm_write_export_func (abfd);
|
||
c = 0;
|
||
sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
|
||
for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
|
||
{
|
||
asymbol *sym;
|
||
bfd_byte len;
|
||
bfd_vma offset;
|
||
bfd_byte temp[NLM_TARGET_LONG_SIZE];
|
||
|
||
sym = *sym_ptr_ptr;
|
||
|
||
if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) == 0
|
||
|| bfd_is_und_section (bfd_get_section (sym)))
|
||
continue;
|
||
|
||
++c;
|
||
|
||
if (get_public_offset_func)
|
||
{
|
||
/* Most backends can use the code below, but
|
||
unfortunately some use a different scheme. */
|
||
offset = (*get_public_offset_func) (abfd, sym);
|
||
}
|
||
else
|
||
{
|
||
offset = bfd_asymbol_value (sym);
|
||
sec = sym->section;
|
||
if (sec->flags & SEC_CODE)
|
||
{
|
||
offset -= nlm_get_text_low (abfd);
|
||
offset |= NLM_HIBIT;
|
||
}
|
||
else if (sec->flags & (SEC_DATA | SEC_ALLOC))
|
||
{
|
||
/* SEC_ALLOC is for the .bss section. */
|
||
offset -= nlm_get_data_low (abfd);
|
||
}
|
||
else
|
||
{
|
||
/* We can't handle an exported symbol that is not in
|
||
the code or data segment. */
|
||
bfd_set_error (bfd_error_invalid_operation);
|
||
goto error_return;
|
||
}
|
||
}
|
||
|
||
if (write_export_func)
|
||
{
|
||
if (! (*write_export_func) (abfd, sym, offset))
|
||
goto error_return;
|
||
}
|
||
else
|
||
{
|
||
len = strlen (sym->name);
|
||
if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
|
||
!= sizeof (bfd_byte))
|
||
|| bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
|
||
goto error_return;
|
||
|
||
put_word (abfd, offset, temp);
|
||
if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd)
|
||
!= sizeof (temp))
|
||
goto error_return;
|
||
}
|
||
}
|
||
nlm_fixed_header (abfd)->numberOfPublics = c;
|
||
|
||
/* Write out the debugging records. The NLM conversion program
|
||
wants to be able to inhibit this, so as a special hack if
|
||
debugInfoOffset is set to -1 we don't write any debugging
|
||
information. This can not be handled by fiddling with the
|
||
symbol table, because exported symbols appear in both the
|
||
exported symbol list and the debugging information. */
|
||
if (nlm_fixed_header (abfd)->debugInfoOffset == (file_ptr) - 1)
|
||
{
|
||
nlm_fixed_header (abfd)->debugInfoOffset = 0;
|
||
nlm_fixed_header (abfd)->numberOfDebugRecords = 0;
|
||
}
|
||
else
|
||
{
|
||
nlm_fixed_header (abfd)->debugInfoOffset = bfd_tell (abfd);
|
||
c = 0;
|
||
sym_ptr_ptr = bfd_get_outsymbols (abfd);
|
||
sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
|
||
for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
|
||
{
|
||
asymbol *sym;
|
||
bfd_byte type, len;
|
||
bfd_vma offset;
|
||
bfd_byte temp[NLM_TARGET_LONG_SIZE];
|
||
|
||
sym = *sym_ptr_ptr;
|
||
|
||
/* The NLM notion of a debugging symbol is actually what
|
||
BFD calls a local or global symbol. What BFD calls a
|
||
debugging symbol NLM does not understand at all. */
|
||
if ((sym->flags & (BSF_LOCAL | BSF_GLOBAL | BSF_EXPORT)) == 0
|
||
|| (sym->flags & BSF_DEBUGGING) != 0
|
||
|| bfd_is_und_section (bfd_get_section (sym)))
|
||
continue;
|
||
|
||
++c;
|
||
|
||
offset = bfd_asymbol_value (sym);
|
||
sec = sym->section;
|
||
if (sec->flags & SEC_CODE)
|
||
{
|
||
offset -= nlm_get_text_low (abfd);
|
||
type = 1;
|
||
}
|
||
else if (sec->flags & (SEC_DATA | SEC_ALLOC))
|
||
{
|
||
/* SEC_ALLOC is for the .bss section. */
|
||
offset -= nlm_get_data_low (abfd);
|
||
type = 0;
|
||
}
|
||
else
|
||
type = 2;
|
||
|
||
/* The type is 0 for data, 1 for code, 2 for absolute. */
|
||
if (bfd_bwrite (&type, (bfd_size_type) sizeof (bfd_byte), abfd)
|
||
!= sizeof (bfd_byte))
|
||
goto error_return;
|
||
|
||
put_word (abfd, offset, temp);
|
||
if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd)
|
||
!= sizeof (temp))
|
||
goto error_return;
|
||
|
||
len = strlen (sym->name);
|
||
if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
|
||
!= sizeof (bfd_byte))
|
||
|| bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
|
||
goto error_return;
|
||
}
|
||
nlm_fixed_header (abfd)->numberOfDebugRecords = c;
|
||
}
|
||
}
|
||
|
||
/* NLMLINK fills in offset values even if there is no data, so we do
|
||
the same. */
|
||
last = bfd_tell (abfd);
|
||
if (nlm_fixed_header (abfd)->codeImageOffset == 0)
|
||
nlm_fixed_header (abfd)->codeImageOffset = last;
|
||
if (nlm_fixed_header (abfd)->dataImageOffset == 0)
|
||
nlm_fixed_header (abfd)->dataImageOffset = last;
|
||
if (nlm_fixed_header (abfd)->customDataOffset == 0)
|
||
nlm_fixed_header (abfd)->customDataOffset = last;
|
||
if (nlm_fixed_header (abfd)->moduleDependencyOffset == 0)
|
||
nlm_fixed_header (abfd)->moduleDependencyOffset = last;
|
||
if (nlm_fixed_header (abfd)->relocationFixupOffset == 0)
|
||
nlm_fixed_header (abfd)->relocationFixupOffset = last;
|
||
if (nlm_fixed_header (abfd)->externalReferencesOffset == 0)
|
||
nlm_fixed_header (abfd)->externalReferencesOffset = last;
|
||
if (nlm_fixed_header (abfd)->publicsOffset == 0)
|
||
nlm_fixed_header (abfd)->publicsOffset = last;
|
||
if (nlm_fixed_header (abfd)->debugInfoOffset == 0)
|
||
nlm_fixed_header (abfd)->debugInfoOffset = last;
|
||
|
||
/* At this point everything has been written out except the fixed
|
||
header. */
|
||
memcpy (nlm_fixed_header (abfd)->signature, nlm_signature (abfd),
|
||
NLM_SIGNATURE_SIZE);
|
||
nlm_fixed_header (abfd)->version = NLM_HEADER_VERSION;
|
||
nlm_fixed_header (abfd)->codeStartOffset =
|
||
(bfd_get_start_address (abfd)
|
||
- nlm_get_text_low (abfd));
|
||
|
||
/* We have no convenient way for the caller to pass in the exit
|
||
procedure or the check unload procedure, so the caller must set
|
||
the values in the header to the values of the symbols. */
|
||
nlm_fixed_header (abfd)->exitProcedureOffset -= nlm_get_text_low (abfd);
|
||
if (nlm_fixed_header (abfd)->checkUnloadProcedureOffset != 0)
|
||
nlm_fixed_header (abfd)->checkUnloadProcedureOffset -=
|
||
nlm_get_text_low (abfd);
|
||
|
||
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
|
||
goto error_return;
|
||
|
||
write_prefix_func = nlm_write_prefix_func (abfd);
|
||
if (write_prefix_func)
|
||
{
|
||
if (! (*write_prefix_func) (abfd))
|
||
goto error_return;
|
||
}
|
||
|
||
BFD_ASSERT ((bfd_size_type) bfd_tell (abfd)
|
||
== nlm_optional_prefix_size (abfd));
|
||
|
||
nlm_swap_fixed_header_out (abfd, nlm_fixed_header (abfd), fixed_header);
|
||
if (bfd_bwrite (fixed_header, nlm_fixed_header_size (abfd), abfd)
|
||
!= nlm_fixed_header_size (abfd))
|
||
goto error_return;
|
||
|
||
if (fixed_header != NULL)
|
||
free (fixed_header);
|
||
return TRUE;
|
||
|
||
error_return:
|
||
if (fixed_header != NULL)
|
||
free (fixed_header);
|
||
return FALSE;
|
||
}
|