bfd/

	* 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.

1 files changed, 94 insertions, 139 deletions

diff --git a/bfd/elf32-xtensa.c b/bfd/elf32-xtensa.c
index 5e4d3ad..495c275 100644
--- a/bfd/elf32-xtensa.c
+++ b/bfd/elf32-xtensa.c
@@ -504,8 +504,7 @@ xtensa_read_table_entries (abfd, section, table_p, sec_name)
   table_section = bfd_get_section_by_name (abfd, table_section_name);
   free (table_section_name);
   if (table_section != NULL)
-    table_size = (table_section->_cooked_size
-		  ? table_section->_cooked_size : table_section->_raw_size);
+    table_size = table_section->size;
   
   if (table_size == 0) 
     {
@@ -562,7 +561,7 @@ xtensa_read_table_entries (abfd, section, table_p, sec_name)
 	  bfd_vma address = bfd_get_32 (abfd, table_data + off);
 
 	  if (address >= section_addr
-	      && address < ( section_addr + section->_raw_size))
+	      && address < section_addr + section->size)
 	    {
 	      blocks[block_count].address = address;
 	      blocks[block_count].size =
@@ -1056,7 +1055,7 @@ elf_xtensa_allocate_plt_size (h, arg)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 
   if (h->plt.refcount > 0)
-    srelplt->_raw_size += (h->plt.refcount * sizeof (Elf32_External_Rela));
+    srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
 
   return TRUE;
 }
@@ -1073,7 +1072,7 @@ elf_xtensa_allocate_got_size (h, arg)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 
   if (h->got.refcount > 0)
-    srelgot->_raw_size += (h->got.refcount * sizeof (Elf32_External_Rela));
+    srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
 
   return TRUE;
 }
@@ -1102,8 +1101,8 @@ elf_xtensa_allocate_local_got_size (info, srelgot)
       for (j = 0; j < cnt; ++j)
 	{
 	  if (local_got_refcounts[j] > 0)
-	    srelgot->_raw_size += (local_got_refcounts[j]
-				   * sizeof (Elf32_External_Rela));
+	    srelgot->size += (local_got_refcounts[j]
+			      * sizeof (Elf32_External_Rela));
 	}
     }
 }
@@ -1137,7 +1136,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info)
 	  s = bfd_get_section_by_name (dynobj, ".interp");
 	  if (s == NULL)
 	    abort ();
-	  s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
+	  s->size = sizeof ELF_DYNAMIC_INTERPRETER;
 	  s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 	}
 
@@ -1145,7 +1144,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info)
       s = bfd_get_section_by_name (dynobj, ".got");
       if (s == NULL)
 	abort ();
-      s->_raw_size = 4;
+      s->size = 4;
 
       /* Adjust refcounts for symbols that we now know are not "dynamic".  */
       elf_link_hash_traverse (elf_hash_table (info),
@@ -1184,7 +1183,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info)
       if (spltlittbl == NULL)
 	abort ();
 
-      plt_entries = srelplt->_raw_size / sizeof (Elf32_External_Rela);
+      plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
       plt_chunks =
 	(plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
 
@@ -1210,15 +1209,15 @@ elf_xtensa_size_dynamic_sections (output_bfd, info)
 
 	  if (chunk_entries != 0)
 	    {
-	      sgotplt->_raw_size = 4 * (chunk_entries + 2);
-	      splt->_raw_size = PLT_ENTRY_SIZE * chunk_entries;
-	      srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
-	      spltlittbl->_raw_size += 8;
+	      sgotplt->size = 4 * (chunk_entries + 2);
+	      splt->size = PLT_ENTRY_SIZE * chunk_entries;
+	      srelgot->size += 2 * sizeof (Elf32_External_Rela);
+	      spltlittbl->size += 8;
 	    }
 	  else
 	    {
-	      sgotplt->_raw_size = 0;
-	      splt->_raw_size = 0;
+	      sgotplt->size = 0;
+	      splt->size = 0;
 	    }
 	}
 
@@ -1227,7 +1226,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info)
       sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
       if (sgotloc == NULL)
 	abort ();
-      sgotloc->_raw_size = spltlittbl->_raw_size;
+      sgotloc->size = spltlittbl->size;
       for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
 	{
 	  if (abfd->flags & DYNAMIC)
@@ -1237,7 +1236,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info)
 	      if (! elf_discarded_section (s)
 		  && xtensa_is_littable_section (s)
 		  && s != spltlittbl)
-		sgotloc->_raw_size += s->_raw_size;
+		sgotloc->size += s->size;
 	    }
 	}
     }
@@ -1273,7 +1272,7 @@ elf_xtensa_size_dynamic_sections (output_bfd, info)
       else if (strncmp (name, ".plt.", 5) == 0
 	       || strncmp (name, ".got.plt.", 9) == 0)
 	{
-	  if (s->_raw_size == 0)
+	  if (s->size == 0)
 	    {
 	      /* If we don't need this section, strip it from the output
 		 file.  We must create the ".plt*" and ".got.plt*"
@@ -1302,8 +1301,8 @@ elf_xtensa_size_dynamic_sections (output_bfd, info)
       else
 	{
 	  /* Allocate memory for the section contents.  */
-	  s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
-	  if (s->contents == NULL && s->_raw_size != 0)
+	  s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
+	  if (s->contents == NULL && s->size != 0)
 	    return FALSE;
 	}
     }
@@ -1439,7 +1438,7 @@ elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
 	  /* Check for windowed CALL across a 1GB boundary.  */
 	  xtensa_opcode opcode =
 	    get_expanded_call_opcode (contents + address,
-				      input_section->_raw_size - address);
+				      input_section->size - address);
 	  if (is_windowed_call_opcode (opcode))
 	    {
 	      self_address = (input_section->output_section->vma
@@ -1460,8 +1459,7 @@ elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
       { 
         /* Convert the L32R/CALLX to CALL.  */
 	bfd_reloc_status_type retval = 
-	  elf_xtensa_do_asm_simplify (contents, address,
-				      input_section->_raw_size);
+	  elf_xtensa_do_asm_simplify (contents, address, input_section->size);
 	if (retval != bfd_reloc_ok)
 	  return retval;
 
@@ -1652,6 +1650,7 @@ bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section,
   bfd_vma relocation;
   bfd_reloc_status_type flag;
   bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
+  bfd_size_type sz;
   bfd_vma output_base = 0;
   reloc_howto_type *howto = reloc_entry->howto;
   asection *reloc_target_output_section;
@@ -1676,8 +1675,8 @@ bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section,
     }
 
   /* Is the address of the relocation really within the section?  */
-  if (reloc_entry->address > (input_section->_cooked_size
-			      / bfd_octets_per_byte (abfd)))
+  sz = input_section->rawsize ? input_section->rawsize : input_section->size;
+  if (reloc_entry->address > sz / bfd_octets_per_byte (abfd))
     return bfd_reloc_outofrange;
 
   /* Work out which section the relocation is targeted at and the
@@ -1895,7 +1894,7 @@ elf_xtensa_relocate_section (output_bfd, info, input_bfd,
 	    {
 	      /* Convert ASM_SIMPLIFY into the simpler relocation
 		 so that they never escape a relaxing link.  */
-	      contract_asm_expansion (contents, input_section->_raw_size, rel);
+	      contract_asm_expansion (contents, input_section->size, rel);
 	      r_type = ELF32_R_TYPE (rel->r_info);
 	    }
 
@@ -1991,7 +1990,7 @@ elf_xtensa_relocate_section (output_bfd, info, input_bfd,
 	}
 
       /* Sanity check the address.  */
-      if (rel->r_offset >= input_section->_raw_size
+      if (rel->r_offset >= input_section->size
 	  && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
 	{
 	  bfd_set_error (bfd_error_bad_value);
@@ -2095,7 +2094,7 @@ elf_xtensa_relocate_section (output_bfd, info, input_bfd,
 		     + srel->reloc_count++ * sizeof (Elf32_External_Rela));
 	      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
 	      BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
-			  <= srel->_cooked_size);
+			  <= srel->size);
 	    }
 	}
 
@@ -2201,13 +2200,11 @@ elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc)
   bfd_vma offset;
   int n, m, num;
 
-  section_size = (sxtlit->_cooked_size != 0
-		  ? sxtlit->_cooked_size : sxtlit->_raw_size);
+  section_size = sxtlit->size;
   BFD_ASSERT (section_size % 8 == 0);
   num = section_size / 8;
 
-  sgotloc_size = (sgotloc->_cooked_size != 0
-		  ? sgotloc->_cooked_size : sgotloc->_raw_size);
+  sgotloc_size = sgotloc->size;
   if (sgotloc_size != section_size)
     {
       (*_bfd_error_handler)
@@ -2215,20 +2212,22 @@ elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc)
       return -1;
     }
 
-  contents = (bfd_byte *) bfd_malloc (section_size);
-  table = (property_table_entry *)
-    bfd_malloc (num * sizeof (property_table_entry));
-  if (contents == 0 || table == 0)
+  table = bfd_malloc (num * sizeof (property_table_entry));
+  if (table == 0)
     return -1;
 
   /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
      propagates to the output section, where it doesn't really apply and
-     where it breaks the following call to bfd_get_section_contents.  */
+     where it breaks the following call to bfd_malloc_and_get_section.  */
   sxtlit->flags &= ~SEC_IN_MEMORY;
 
-  if (! bfd_get_section_contents (output_bfd, sxtlit, contents, 0,
-				  section_size))
-    return -1;
+  if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
+    {
+      if (contents != 0)
+	free (contents);
+      free (table);
+      return -1;
+    }
 
   /* There should never be any relocations left at this point, so this
      is quite a bit easier than what is done during relaxation.  */
@@ -2282,7 +2281,7 @@ elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc)
   if ((bfd_size_type) (num * 8) < section_size)
     {
       memset (&contents[num * 8], 0, section_size - num * 8);
-      sxtlit->_cooked_size = num * 8;
+      sxtlit->size = num * 8;
     }
 
   if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
@@ -2322,7 +2321,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
   sgot = bfd_get_section_by_name (dynobj, ".got");
   if (sgot)
     {
-      BFD_ASSERT (sgot->_raw_size == 4);
+      BFD_ASSERT (sgot->size == 4);
       if (sdyn == NULL)
 	bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
       else
@@ -2332,7 +2331,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
     }
 
   srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
-  if (srelplt != NULL && srelplt->_raw_size != 0)
+  if (srelplt != NULL && srelplt->size != 0)
     {
       asection *sgotplt, *srelgot, *spltlittbl;
       int chunk, plt_chunks, plt_entries;
@@ -2357,7 +2356,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
 	}
       BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
 
-      plt_entries = (srelplt->_raw_size / sizeof (Elf32_External_Rela));
+      plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
       plt_chunks =
 	(plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
 
@@ -2399,7 +2398,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
 	  else
 	    chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
 
-	  BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->_cooked_size);
+	  BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
 	  bfd_put_32 (output_bfd,
 		      sgotplt->output_section->vma + sgotplt->output_offset,
 		      spltlittbl->contents + (chunk * 8) + 0);
@@ -2410,10 +2409,10 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
 
       /* All the dynamic relocations have been emitted at this point.
 	 Make sure the relocation sections are the correct size.  */
-      if (srelgot->_cooked_size != (sizeof (Elf32_External_Rela)
-				    * srelgot->reloc_count)
-	  || srelplt->_cooked_size != (sizeof (Elf32_External_Rela)
-				       * srelplt->reloc_count))
+      if (srelgot->size != (sizeof (Elf32_External_Rela)
+			    * srelgot->reloc_count)
+	  || srelplt->size != (sizeof (Elf32_External_Rela)
+			       * srelplt->reloc_count))
 	abort ();
 
      /* The .xt.lit.plt section has just been modified.  This must
@@ -2424,7 +2423,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
 				      spltlittbl->output_section,
 				      spltlittbl->contents,
 				      spltlittbl->output_offset,
-				      spltlittbl->_raw_size))
+				      spltlittbl->size))
 	return FALSE;
       /* Clear SEC_HAS_CONTENTS so the contents won't be output again.  */
       spltlittbl->flags &= ~SEC_HAS_CONTENTS;
@@ -2441,7 +2440,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
     return FALSE;
 
   dyncon = (Elf32_External_Dyn *) sdyn->contents;
-  dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
+  dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
   for (; dyncon < dynconend; dyncon++)
     {
       Elf_Internal_Dyn dyn;
@@ -2476,7 +2475,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
 	case DT_PLTRELSZ:
 	  s = bfd_get_section_by_name (output_bfd, ".rela.plt");
 	  BFD_ASSERT (s);
-	  dyn.d_un.d_val = (s->_cooked_size ? s->_cooked_size : s->_raw_size);
+	  dyn.d_un.d_val = s->size;
 	  break;
 
 	case DT_RELASZ:
@@ -2488,10 +2487,7 @@ elf_xtensa_finish_dynamic_sections (output_bfd, info)
 	     don't have to worry about changing the DT_RELA entry.  */
 	  s = bfd_get_section_by_name (output_bfd, ".rela.plt");
 	  if (s)
-	    {
-	      dyn.d_un.d_val -=
-		(s->_cooked_size ? s->_cooked_size : s->_raw_size);
-	    }
+	    dyn.d_un.d_val -= s->size;
 	  break;
 	}
 
@@ -2687,7 +2683,7 @@ elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)
   bfd_vma offset, actual_offset;
   size_t removed_bytes = 0;
 
-  section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
+  section_size = sec->size;
   if (section_size == 0 || section_size % 8 != 0)
     return FALSE;
 
@@ -2775,9 +2771,8 @@ elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)
       pin_contents (sec, contents);
       pin_internal_relocs (sec, cookie->rels);
 
-      sec->_cooked_size = section_size - removed_bytes;
-      /* Also shrink _raw_size.  See comments in relax_property_section.  */
-      sec->_raw_size = sec->_cooked_size;
+      /* Shrink size.  */
+      sec->size = section_size - removed_bytes;
 
       if (xtensa_is_littable_section (sec))
 	{
@@ -2787,13 +2782,7 @@ elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)
 	      asection *sgotloc =
 		bfd_get_section_by_name (dynobj, ".got.loc");
 	      if (sgotloc)
-		{
-		  bfd_size_type sgotloc_size =
-		    (sgotloc->_cooked_size ? sgotloc->_cooked_size
-		     : sgotloc->_raw_size);
-		  sgotloc->_cooked_size = sgotloc_size - removed_bytes;
-		  sgotloc->_raw_size = sgotloc_size - removed_bytes;
-		}
+		sgotloc->size -= removed_bytes;
 	    }
 	}
     }
@@ -2845,7 +2834,7 @@ elf_xtensa_grok_prstatus (abfd, note)
      Elf_Internal_Note *note;
 {
   int offset;
-  unsigned int raw_size;
+  unsigned int size;
 
   /* The size for Xtensa is variable, so don't try to recognize the format
      based on the size.  Just assume this is GNU/Linux.  */
@@ -2858,11 +2847,11 @@ elf_xtensa_grok_prstatus (abfd, note)
 
   /* pr_reg */
   offset = 72;
-  raw_size = note->descsz - offset - 4;
+  size = note->descsz - offset - 4;
 
   /* Make a ".reg/999" section.  */
   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
-					  raw_size, note->descpos + offset);
+					  size, note->descpos + offset);
 }
 
 
@@ -3024,7 +3013,7 @@ get_relocation_opcode (sec, contents, irel)
   if (contents == NULL)
     return XTENSA_UNDEFINED;
 
-  if (sec->_raw_size <= irel->r_offset)
+  if (sec->size <= irel->r_offset)
     return XTENSA_UNDEFINED;
 
   if (ibuff == NULL)
@@ -3958,20 +3947,16 @@ retrieve_contents (abfd, sec, keep_memory)
 
   contents = elf_section_data (sec)->this_hdr.contents;
   
-  if (contents == NULL && sec->_raw_size != 0)
+  if (contents == NULL && sec->size != 0)
     {
-      contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
-      if (contents != NULL)
+      if (!bfd_malloc_and_get_section (abfd, sec, &contents))
 	{
-	  if (! bfd_get_section_contents (abfd, sec, contents,
-					  (file_ptr) 0, sec->_raw_size))
-	    {
-	      free (contents);
-	      return NULL;
-	    }
-	  if (keep_memory) 
-	    elf_section_data (sec)->this_hdr.contents = contents;
+	  if (contents != NULL)
+	    free (contents);
+	  return NULL;
 	}
+      if (keep_memory) 
+	elf_section_data (sec)->this_hdr.contents = contents;
     }
   return contents;
 }
@@ -4197,7 +4182,7 @@ find_relaxable_sections (abfd, sec, link_info, is_relaxable_p)
     return ok;
 
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
-  if (contents == NULL && sec->_raw_size != 0)
+  if (contents == NULL && sec->size != 0)
     {
       ok = FALSE;
       goto error_return;
@@ -4258,7 +4243,7 @@ collect_source_relocs (abfd, sec, link_info)
     return ok;
 
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
-  if (contents == NULL && sec->_raw_size != 0)
+  if (contents == NULL && sec->size != 0)
     {
       ok = FALSE;
       goto error_return;
@@ -4406,7 +4391,7 @@ is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
     return FALSE;
   
   opcode = get_expanded_call_opcode (contents + irel->r_offset,
-				     sec->_raw_size - irel->r_offset);
+				     sec->size - irel->r_offset);
   
   direct_call_opcode = swap_callx_for_call_opcode (opcode);
   if (direct_call_opcode == XTENSA_UNDEFINED)
@@ -4509,7 +4494,7 @@ remove_literals (abfd, sec, link_info, values)
 					      link_info->keep_memory);
 
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
-  if (contents == NULL && sec->_raw_size != 0)
+  if (contents == NULL && sec->size != 0)
     {
       ok = FALSE;
       goto error_return;
@@ -4567,7 +4552,7 @@ remove_literals (abfd, sec, link_info, values)
 
       /* Find the literal value.  */
       r_reloc_init (&val.r_rel, abfd, irel);
-      BFD_ASSERT (rel->r_rel.target_offset < sec->_raw_size);
+      BFD_ASSERT (rel->r_rel.target_offset < sec->size);
       val.value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
           
       /* Check if we've seen another literal with the same value.  */
@@ -4723,7 +4708,7 @@ relax_section (abfd, sec, link_info)
   internal_relocs = retrieve_internal_relocs (abfd, sec, 
 					      link_info->keep_memory);
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
-  if (contents == NULL && sec->_raw_size != 0)
+  if (contents == NULL && sec->size != 0)
     {
       ok = FALSE;
       goto error_return;
@@ -4802,13 +4787,13 @@ relax_section (abfd, sec, link_info)
       /* Walk through the contents and delete literals that are not needed 
          anymore.  */
 
-      unsigned long size = sec->_cooked_size;
+      unsigned long size = sec->size;
       unsigned long removed = 0;
 
       removed_literal *reloc = relax_info->removed_list.head;
       for (; reloc; reloc = reloc->next) 
 	{
-	  unsigned long upper = sec->_raw_size;
+	  unsigned long upper = sec->size;
 	  bfd_vma start = reloc->from.target_offset + 4;
 	  if (reloc->next)
 	    upper = reloc->next->from.target_offset;
@@ -4825,13 +4810,7 @@ relax_section (abfd, sec, link_info)
 	}
 
       /* Change the section size.  */
-      sec->_cooked_size = size;
-      /* Also shrink _raw_size.  (The code in relocate_section that
-	 checks that relocations are within the section must use
-	 _raw_size because of the way the stabs sections are relaxed;
-	 shrinking _raw_size means that these checks will not be
-	 unnecessarily lax.)  */
-      sec->_raw_size = size;
+      sec->size = size;
     }
   
  error_return:
@@ -4957,13 +4936,8 @@ shrink_dynamic_reloc_sections (info, abfd, input_section, rel)
       /* Reduce size of the .rela.* section by one reloc.  */
       srel = bfd_get_section_by_name (dynobj, srel_name);
       BFD_ASSERT (srel != NULL);
-      BFD_ASSERT (srel->_cooked_size >= sizeof (Elf32_External_Rela));
-      srel->_cooked_size -= sizeof (Elf32_External_Rela);
-
-      /* Also shrink _raw_size.  (This seems wrong but other bfd code seems
-	 to assume that linker-created sections will never be relaxed and
-	 hence _raw_size must always equal _cooked_size.) */
-      srel->_raw_size = srel->_cooked_size;
+      BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
+      srel->size -= sizeof (Elf32_External_Rela);
 
       if (is_plt)
 	{
@@ -4976,7 +4950,7 @@ shrink_dynamic_reloc_sections (info, abfd, input_section, rel)
 	     = size - 1" since the index starts at zero, but in this
 	     context, the size has just been decremented so there's no
 	     need to subtract one.  */
-	  reloc_index = srel->_cooked_size / sizeof (Elf32_External_Rela);
+	  reloc_index = srel->size / sizeof (Elf32_External_Rela);
 
 	  chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
 	  splt = elf_xtensa_get_plt_section (dynobj, chunk);
@@ -4990,27 +4964,20 @@ shrink_dynamic_reloc_sections (info, abfd, input_section, rel)
 	      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 	      BFD_ASSERT (srelgot != NULL);
 	      srelgot->reloc_count -= 2;
-	      srelgot->_cooked_size -= 2 * sizeof (Elf32_External_Rela);
-	      /* Shrink _raw_size (see comment above).  */
-	      srelgot->_raw_size = srelgot->_cooked_size;
-
-	      sgotplt->_cooked_size -= 8;
+	      srelgot->size -= 2 * sizeof (Elf32_External_Rela);
+	      sgotplt->size -= 8;
 
 	      /* There should be only one entry left (and it will be
 		 removed below).  */
-	      BFD_ASSERT (sgotplt->_cooked_size == 4);
-	      BFD_ASSERT (splt->_cooked_size == PLT_ENTRY_SIZE);
+	      BFD_ASSERT (sgotplt->size == 4);
+	      BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
 	    }
 
-	  BFD_ASSERT (sgotplt->_cooked_size >= 4);
-	  BFD_ASSERT (splt->_cooked_size >= PLT_ENTRY_SIZE);
-
-	  sgotplt->_cooked_size -= 4;
-	  splt->_cooked_size -= PLT_ENTRY_SIZE;
+	  BFD_ASSERT (sgotplt->size >= 4);
+	  BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
 
-	  /* Shrink _raw_sizes (see comment above).  */
-	  sgotplt->_raw_size = sgotplt->_cooked_size;
-	  splt->_raw_size = splt->_cooked_size;
+	  sgotplt->size -= 4;
+	  splt->size -= PLT_ENTRY_SIZE;
 	}
     }
 }
@@ -5035,7 +5002,7 @@ relax_property_section (abfd, sec, link_info)
   internal_relocs = retrieve_internal_relocs (abfd, sec, 
 					      link_info->keep_memory);
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
-  if (contents == NULL && sec->_raw_size != 0)
+  if (contents == NULL && sec->size != 0)
     {
       ok = FALSE;
       goto error_return;
@@ -5126,7 +5093,7 @@ relax_property_section (abfd, sec, link_info)
       pin_contents (sec, contents);
 
       last_irel_offset = (bfd_vma) -1;
-      section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
+      section_size = sec->size;
       BFD_ASSERT (section_size % 8 == 0);
 
       for (offset = 0; offset < section_size; offset += 8)
@@ -5258,13 +5225,7 @@ relax_property_section (abfd, sec, link_info)
 	  /* Clear the removed bytes.  */
 	  memset (&contents[section_size - removed_bytes], 0, removed_bytes);
 
-	  sec->_cooked_size = section_size - removed_bytes;
-	  /* Also shrink _raw_size.  (The code in relocate_section that
-	     checks that relocations are within the section must use
-	     _raw_size because of the way the stabs sections are
-	     relaxed; shrinking _raw_size means that these checks will
-	     not be unnecessarily lax.)  */
-	  sec->_raw_size = sec->_cooked_size;
+	  sec->size = section_size - removed_bytes;
 
 	  if (xtensa_is_littable_section (sec))
 	    {
@@ -5274,13 +5235,7 @@ relax_property_section (abfd, sec, link_info)
 		  asection *sgotloc =
 		    bfd_get_section_by_name (dynobj, ".got.loc");
 		  if (sgotloc)
-		    {
-		      bfd_size_type sgotloc_size =
-			(sgotloc->_cooked_size ? sgotloc->_cooked_size
-			 : sgotloc->_raw_size);
-		      sgotloc->_cooked_size = sgotloc_size - removed_bytes;
-		      sgotloc->_raw_size = sgotloc_size - removed_bytes;
-		    }
+		    sgotloc->size -= removed_bytes;
 		}
 	    }
 	}
@@ -5739,7 +5694,7 @@ xtensa_callback_required_dependence (abfd, sec, link_info, callback, closure)
       /* Assume worst-case offsets: L32R at the very end of the ".plt"
 	 section referencing a literal at the very beginning of
 	 ".got.plt".  This is very close to the real dependence, anyway.  */
-      (*callback) (sec, sec->_raw_size, sgotplt, 0, closure);
+      (*callback) (sec, sec->size, sgotplt, 0, closure);
     }
 
   internal_relocs = retrieve_internal_relocs (abfd, sec, 
@@ -5750,7 +5705,7 @@ xtensa_callback_required_dependence (abfd, sec, link_info, callback, closure)
 
   /* Cache the contents for the duration of this scan.  */
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
-  if (contents == NULL && sec->_raw_size != 0)
+  if (contents == NULL && sec->size != 0)
     {
       ok = FALSE;
       goto error_return;