Import of Binutils from the FSF 2.13 branch (just pre-.2 release).

These bits are taken from the FSF anoncvs repo on 27-Oct-2002 21:12:00 EST.

60 files changed, 10910 insertions, 749 deletions

diff --git a/contrib/binutils/bfd/ChangeLog b/contrib/binutils/bfd/ChangeLog
index 1d3c161..6c92f76 100644
--- a/contrib/binutils/bfd/ChangeLog
+++ b/contrib/binutils/bfd/ChangeLog
@@ -1,7 +1,276 @@
+2002-11-27  David O'Brien  <obrien@FreeBSD.org>
+
+        * elf.c (_bfd_elf_copy_private_section_data): Don't define bed.
+
+2002-11-21  Richard Henderson  <rth@redhat.com>
+
+        * elflink.h (elf_link_add_object_symbols): Don't overwrite the
+        arch's st_other bits when merging visibilities.
+        (elf_link_output_extsym): Tidy clearing of visibility field.
+
+2002-11-14  David O'Brien  <obrien@FreeBSD.org>
+
+	Merge from mainline:
+	2002-11-12  Thomas Moestl <tmm@FreeBSD.org>
+	* elf64-sparc.c (sparc64_elf_adjust_dynamic_symbol): Correct
+	references to large plt symbols.
+
+2002-11-13  Alan Modra  <amodra@bigpond.net.au>
+
+	Merge from mainline.
+	2002-11-07  Alan Modra  <amodra@bigpond.net.au>
+	* elf64-ppc.c: Comment typo fixes.
+	(ppc64_elf_merge_private_bfd_data): Allow BFD_ENDIAN_UNKNOWN input.
+
+2002-11-11  Nick Clifton  <nickc@redhat.com>
+	
+	Import this patch from mainline:
+	
+	2002-09-19  Nick Clifton  <nickc@redhat.com>
+	
+	* elflink.h (elf_fix_symbol_flags): When examining weak symbols,
+	follow indirect links.
+
+2002-11-07  Daniel Jacobowitz  <drow@mvista.com>
+
+	* configure.in: Clear is_release on the branch after release.
+
+2002-11-07  Daniel Jacobowitz  <drow@mvista.com>
+
+	* configure.in: Bump version and set is_release.
+	* configure: Regenerate.
+
+2002-11-07  Nick Clifton  <nickc@redhat.com>
+
+	* po/da.po: Updated Danish translation.
+
+2002-11-07  Graeme Peterson  <gp@qnx.com>
+
+	* Makefile.am: Removed entries for elf32-i386qnx.c and
+	elf32-i386qnx.lo.
+	* Makefile.in: Regenerate.
+	* config.bfd: Changed i[3456]86-*-nto-qnx* targ_defvec from
+	bfd_elf32_i386qnx_vec to bfd_elf32_i386_vec.
+	* configure.in: Removed support for bfd_elf32_i386qnx_vec.
+	* configure: Regenerate.
+	* elf32-i386qnx.c: Removed.
+	* elf.c: Removed calls to QNX specific set_nonloadable_filepos,
+	is_contained_by_filepos, and copy_private_bfd_data_p.
+	* elf32-i386.c: Removed QNX specific #ifdef ELF32_I386_C_INCLUDED.
+	* targets.c: Removed bfd_elf32_i386qnx_vec.
+	* elfxx-target.h: Removed QNX specific elf_backend_set_nonloadable_filepos,
+	elf_backend_is_contained_by_filepos, and elf_backend_copy_private_bfd_data_p.
+	* elf-bfd.h: Removed QNX specific set_nonloadable_filepos,
+	is_contained_by_filepos, and copy_private_bfd_data_p.
+
+2002-11-06  David O'Brien  <obrien@FreeBSD.org>
+	    Alan Modra  <amodra@bigpond.net.au>
+
+	* elf64-sparc.c (sparc64_elf_relocate_section): Adjust addend of
+	dynamic relocs against section symbols for the output section vma.
+
+2002-11-05  Elias Athanasopoulos  <eathan@otenet.gr>
+
+	* vms-gsd.c (_bfd_vms_write_gsd): Check that symbol->udata.p is
+	non-NULL before dereferencing.
+
+2002-11-04  Kaz Kojima  <kkojima@rr.iij4u.or.jp>
+
+	* vms.c (vms_object_p): Restore the start address when returning
+	NULL.
+
+2002-10-31  David O'Brien  <obrien@FreeBSD.org>
+
+	* elf-eh-frame.c (_bfd_elf_discard_section_eh_frame): Don't mix
+	signed and unsigned in comparison.
+
+2002-10-30  Daniel Jacobowitz  <drow@mvista.com>
+
+	* bfd-in2.h: Regenerated.
+	* po/SRC-POTFILES.in: Regenerated.
+	* po/bfd.pot: Regenerated.
+
+2002-10-30  Daniel Jacobowitz  <drow@mvista.com>
+
+	* coffcode.h: Remove extraneous '\'.
+
+2002-10-28  Daniel Jacobowitz  <drow@mvista.com>
+
+	Merge from mainline:
+	2002-10-24  John David Anglin  <dave@hiauly1.hia.nrc.ca>
+	* aoutx.h (NAME(aout,swap_ext_reloc_in)): Cast bytes->r_index to
+	unsigned int.  Cast RELOC_BASE10, RELOC_BASE13 and RELOC_BASE22 to
+	unsigned int.
+	(NAME(aout,final_link)): Cast enum used in assignment.
+	(aout_link_write_symbols): Cast enums in comparisons, int values to
+	boolean, enums in assignments to int.
+	(aout_link_input_section_std): Cast rel->r_index to unsigned int.
+	(aout_link_input_section_ext): Likewise.  Cast enums used in comparisons
+	with unsigned ints.
+	(aout_link_reloc_link_order): Cast enum to int in assignment.
+	* archive.c (_bfd_generic_read_ar_hdr_mag): Cast result of memchr
+	calls to char *.
+	* bfd-in.h (bfd_set_section_vma): Cast enum true to unsigned int in
+	assignment.
+	* bfd-in2.h (bfd_set_section_vma): Likewise.
+	* bfd.c (bfd_record_phdr): Cast enums in assignments.
+	* binary.c (bfd_alloc): Cast enum to long.
+	* coffgen.c (_bfd_coff_is_local_label_name): Cast return to boolean.
+	* dwarf2.c (read_abbrevs): Add casts to enum types.
+	(read_attribute_value): Likewise.
+	(arange_add): Cast result of bfd_zalloc call.
+	(comp_unit_contains_address): Return true and false.
+	(comp_unit_find_nearest_line): Cast return to boolean.
+	* format.c (bfd_check_format_matches, bfd_set_format): Likewise.
+	* gen-aout.c: define macro '_' if not defined.
+	* libbfd.c (bfd_realloc): Cast malloc and realloc to PTR.
+	(bfd_bwrite): Cast bfd_realloc to bfd_byte *.
+	(bfd_write_bigendian_4byte_int): Cast return to boolean.
+	(bfd_seek): Cast bfd_realloc to bfd_byte *.
+	(bfd_generic_is_local_label_name): Cast return to boolean.
+	* libcoff.h (_bfd_coff_adjust_symndx): Remove extraneous '\'.
+	* linker.c (_bfd_link_hash_newfunc): Cast bfd_hash_allocate result to
+	struct bfd_hash_entry *.
+	(_bfd_generic_link_hash_newfunc): likewise.
+	(_bfd_generic_final_link): Cast enum to unsigned int.
+	* merge.c (sec_merge_emit): Cast return to boolean.
+	(merge_strings): Add casts to const unsigned char *.
+	* reloc.c (bfd_get_reloc_code_name): Cast enums in comparison to int.
+	(bfd_generic_get_relocated_section_content): Cast enum to unsigned int.
+	* section.c (bfd_section_hash_newfunc): Cast bfd_hash_allocate result to
+	struct bfd_hash_entry *.
+	(bfd_set_section_content): Add cast to PTR in comparison.
+	* srec.c (S3Forced): Initialize to false.
+	(srec_get_symtab): Cast return value from bfd_alloc to asymbol *.
+	* stabs.c (_bfd_link_section_stabs): Cast enum to int in comparisons.
+	(_bfd_discard_section_stabs): Likewise.  Also cast return to boolean.
+	* syms.c (bfd_is_undefined_symclass): Cast return to boolean.
+	(_bfd_stab_section_find_nearest_line): Cast enum to bfd_byte in
+	comparisons.
+
+	2002-10-23  Jakub Jelinek  <jakub@redhat.com>
+	* elf64-alpha.c (elf64_alpha_check_relocs): Only put maybe_dynamic
+	relocs into shared lib non-allocated reloc sections.
+
+	2002-10-23  Nathan Tallent  <eraxxon@alumni.rice.edu>
+	* dwarf2.c (add_line_info): Ensure that the line_info_table is
+	sorted even when given an out-of-order line sequence.
+	(lookup_address_in_line_info_table): When an exact VMA match is
+	not found, return line information with the closest VMA.
+
+	2002-10-21  Alan Modra  <amodra@bigpond.net.au>
+	* targets.c (bfd_target_list): Don't return the default target twice.
+
+	2002-10-19  H.J. Lu <hjl@gnu.org>
+	* elflink.h (elf_link_add_object_symbols): Correctly handle
+	DT_RPATH and DT_RUNPATH.
+
+	2002-10-16  Jakub Jelinek  <jakub@redhat.com>
+	* config.bfd (s390-*-linux*): Add targ64_selvecs.
+	(s390x-*-linux*): Add targ_selvecs.
+
+	2002-10-16  Alan Modra  <amodra@bigpond.net.au>
+	* elflink.h (elf_link_add_object_symbols): Error out on dynamic objects
+	loaded with --just-symbols.
+
+	* elf32-i386qnx.c (TARGET_LITTLE_NAME): Define.
+
+	2002-10-14  Kaz Kojima  <kkojima@rr.iij4u.or.jp>
+	* config.bfd (sh*eb-*-linux*, sh*-*-linux*): Add the alternative
+	endian vector to targ_selvecs.
+
+	2002-10-08  H.J. Lu <hjl@gnu.org>
+	* elf32-i386.c (elf_i386_relocate_section): Re-arrange the
+	IE->LE transition for R_386_TLS_IE.
+
+	2002-10-07  Mark Elbrecht  <snowball3@softhome.net>
+	* cofflink.c (mark_relocs): Don't mark relocations in excluded
+	sections.
+
+	2002-10-05  Alexandre Oliva  <aoliva@redhat.com>
+	* elfxx-mips.c (mips_elf_create_dynamic_relocation): Set the type
+	of the other two relocations packed with a REL32 to NONE.
+
+	2002-10-02  Stephen Clarke <stephen.clarke@superh.com>
+	* elf32-sh.c (elf_sh_link_hash_entry): Add gotplt_refcount.
+	(sh_elf_link_hash_newfunc): Initialize it.
+	(allocate_dynrelocs): Transfer gotplt refs from plt.refcount
+	to got.refcount for symbols that are forced local or when
+	we have direct got refs.
+	(sh_elf_gc_sweep_hook): Adjust gotplt_refcount.  Use it
+	to correctly adjust got.refcount and plt.refcount.
+	(sh_elf_copy_indirect_symbol): Copy gotplt_refcount across.
+	(sh_elf_check_relocs): Increment gotplt_refcount.
+
+	2002-10-01  Jakub Jelinek  <jakub@redhat.com>
+	* elf32-i386.c (elf_i386_relocate_section): Fix
+	movl foo@indntpoff, %eax IE->LE transition.
+
+	2002-09-28  Jason Thorpe  <thorpej@wasabisystems.com>
+	* elf32-vax.c (elf_vax_size_dynamic_section): Don't strip
+	.got sections.
+
+	2002-09-27  Matt Thomas  <matt@3am-software.com>
+	* elf32-vax.c (elf_vax_check_relocs): Remove unused
+	local_got_refcounts usage.  Remove allocation of got slot.
+	(elf_vax_gc_sweep_hook): Remove unused local_got_refcounts usage.
+	Remove de-allocation of got slot.
+	(elf_vax_size_dynamic_section): Fix some indentation.  Add hash
+	traversal for elf_vax_instantiate_got_entries.  Allow empty .got
+	sections to be GC'ed.
+	(elf_vax_instantiate_got_entries): New function.
+	(elf_vax_relocate_section): Simplify R_VAX_GOT32 handling.  Remove
+	tests that are now handled by elf_vax_instantiate_got_entries.
+	Assert GOT entry falls within .got section size.  Remove redundant
+	comparisions.  Fix comments.
+
+	2002-09-24  Jakub Jelinek  <jakub@redhat.com>
+	* elf32-sparc.c (elf32_sparc_relocate_section): Put R_SPARC_RELATIVE
+	addend into r_addend, not *r_offset.
+	(elf32_sparc_finish_dynamic_symbol): Likewise.
+	* elf64-sparc.c (sparc64_elf_finish_dynamic_symbol): Clear xword at
+	R_SPARC_RELATIVE's r_offset.
+
+	2002-08-07  Thiemo Seufer <seufer@csv.ica.uni-stuttgart.de>
+	* elfxx-mips.c (mips_elf_create_dynamic_relocation): Cast signedness
+	mismatch.
+
+2002-10-14  Richard Henderson  <rth@redhat.com>
+
+	* elf64-alpha.c (elf64_alpha_relocate_section) [BRSGP]: Increment
+	VALUE, not ADDEND.
+
 2002-10-11  Alan Modra  <amodra@bigpond.net.au>
 
+	* coff-arm.c (record_arm_to_thumb_glue): Avoid type-punned pointers.
+	(record_thumb_to_arm_glue): Likewise.
+	* ecoff.c (ecoff_link_add_externals): Likewise.
+	* elf32-arm.h (record_arm_to_thumb_glue): Likewise.
+	(record_thumb_to_arm_glue): Likewise.
+	* elf32-m32r.c (m32r_elf_add_symbol_hook): Likewise.
+	* elf32-sh.c (sh_elf_create_dynamic_sections): Likewise.
+	* elf32-sh64.c (sh64_elf_add_symbol_hook): Likewise.
+	* elf64-alpha.c (elf64_alpha_create_dynamic_sections): Likewise.
+	* elf64-ppc.c (func_desc_adjust): Likewise.
+	* elf64-sh64.c (sh64_elf64_add_symbol_hook): Likewise.
+	(sh64_elf64_create_dynamic_sections): Likewise.
+	* elflink.c (_bfd_elf_create_got_section): Likewise.
+	(_bfd_elf_create_dynamic_sections): Likewise.
+	(_bfd_elf_create_linker_section): Likewise.
+	* elflink.h (elf_add_default_symbol): Likewise.
+	(elf_link_create_dynamic_sections): Likewise.
+	(NAME(bfd_elf,size_dynamic_sections)): Likewise.
+	* elfxx-ia64.c (elfNN_ia64_aix_add_symbol_hook): Likewise.
+	* elfxx-mips.c (mips_elf_create_got_section): Likewise.
+	(_bfd_mips_elf_add_symbol_hook): Likewise.
+	(_bfd_mips_elf_create_dynamic_sections): Likewise.
+	* linker.c (generic_link_add_symbol_list): Likewise.
+	* xcofflink.c (xcoff_link_add_symbols): Likewise.
+
+	* elfxx-ia64.c (oor_brl, oor_ip): Conditionally define.
+
 	* elf64-ppc.c (edit_opd): Only zero opd syms when function is
-	completely removed.
+	completely removed.  Correct local sym adjustment.
 
 2002-10-08  Alan Modra  <amodra@bigpond.net.au>
 
diff --git a/contrib/binutils/bfd/Makefile.am b/contrib/binutils/bfd/Makefile.am
index f56ceb0..1213897 100644
--- a/contrib/binutils/bfd/Makefile.am
+++ b/contrib/binutils/bfd/Makefile.am
@@ -211,7 +211,6 @@ BFD32_BACKENDS = \
 	elf32-i370.lo \
 	elf32-i386.lo \
 	elf32-i386-fbsd.lo \
-	elf32-i386qnx.lo \
 	elf32-i860.lo \
 	elf32-i960.lo \
 	elf32-ia64.lo \
@@ -369,7 +368,6 @@ BFD32_BACKENDS_CFILES = \
 	elf32-i370.c \
 	elf32-i386.c \
 	elf32-i386-fbsd.c \
-	elf32-i386qnx.c \
 	elf32-i860.c \
 	elf32-i960.c \
 	elf32-m32r.c \
@@ -1145,10 +1143,6 @@ elf32-i386-fbsd.lo: elf32-i386-fbsd.c elf32-i386.c $(INCDIR)/filenames.h \
   $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
   $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/elf/i386.h \
   $(INCDIR)/elf/reloc-macros.h elf32-target.h
-elf32-i386qnx.lo: elf32-i386qnx.c elf32-i386.c $(INCDIR)/filenames.h \
-  $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
-  $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/elf/i386.h \
-  $(INCDIR)/elf/reloc-macros.h elf32-target.h
 elf32-i860.lo: elf32-i860.c $(INCDIR)/filenames.h elf-bfd.h \
   $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
   $(INCDIR)/bfdlink.h $(INCDIR)/elf/i860.h $(INCDIR)/elf/reloc-macros.h \
diff --git a/contrib/binutils/bfd/Makefile.in b/contrib/binutils/bfd/Makefile.in
index 6744de0..dd4ff4f 100644
--- a/contrib/binutils/bfd/Makefile.in
+++ b/contrib/binutils/bfd/Makefile.in
@@ -1,6 +1,6 @@
-# Makefile.in generated automatically by automake 1.4-p5 from Makefile.am
+# Makefile.in generated automatically by automake 1.4 from Makefile.am
 
-# Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc.
+# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
@@ -339,7 +339,6 @@ BFD32_BACKENDS = \
 	elf32-i370.lo \
 	elf32-i386.lo \
 	elf32-i386-fbsd.lo \
-	elf32-i386qnx.lo \
 	elf32-i860.lo \
 	elf32-i960.lo \
 	elf32-ia64.lo \
@@ -498,7 +497,6 @@ BFD32_BACKENDS_CFILES = \
 	elf32-i370.c \
 	elf32-i386.c \
 	elf32-i386-fbsd.c \
-	elf32-i386qnx.c \
 	elf32-i860.c \
 	elf32-i960.c \
 	elf32-m32r.c \
@@ -933,7 +931,7 @@ maintainer-clean-recursive:
 	dot_seen=no; \
 	rev=''; list='$(SUBDIRS)'; for subdir in $$list; do \
 	  rev="$$subdir $$rev"; \
-	  test "$$subdir" != "." || dot_seen=yes; \
+	  test "$$subdir" = "." && dot_seen=yes; \
 	done; \
 	test "$$dot_seen" = "no" && rev=". $$rev"; \
 	target=`echo $@ | sed s/-recursive//`; \
@@ -1675,10 +1673,6 @@ elf32-i386-fbsd.lo: elf32-i386-fbsd.c elf32-i386.c $(INCDIR)/filenames.h \
   $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
   $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/elf/i386.h \
   $(INCDIR)/elf/reloc-macros.h elf32-target.h
-elf32-i386qnx.lo: elf32-i386qnx.c elf32-i386.c $(INCDIR)/filenames.h \
-  $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
-  $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/elf/i386.h \
-  $(INCDIR)/elf/reloc-macros.h elf32-target.h
 elf32-i860.lo: elf32-i860.c $(INCDIR)/filenames.h elf-bfd.h \
   $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
   $(INCDIR)/bfdlink.h $(INCDIR)/elf/i860.h $(INCDIR)/elf/reloc-macros.h \
diff --git a/contrib/binutils/bfd/aout-tic30.c b/contrib/binutils/bfd/aout-tic30.c
index e3c74fa..a39a5b1 100644
--- a/contrib/binutils/bfd/aout-tic30.c
+++ b/contrib/binutils/bfd/aout-tic30.c
@@ -1,5 +1,5 @@
 /* BFD back-end for TMS320C30 a.out binaries.
-   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
    Contributed by Steven Haworth (steve@pm.cse.rmit.edu.au)
 
    This file is part of BFD, the Binary File Descriptor library.
@@ -965,6 +965,9 @@ tic30_aout_set_arch_mach (abfd, arch, machine)
 #ifndef MY_bfd_merge_sections
 #define MY_bfd_merge_sections bfd_generic_merge_sections
 #endif
+#ifndef MY_bfd_discard_group
+#define MY_bfd_discard_group bfd_generic_discard_group
+#endif
 #ifndef MY_bfd_reloc_type_lookup
 #define MY_bfd_reloc_type_lookup tic30_aout_reloc_type_lookup
 #endif
@@ -980,9 +983,15 @@ tic30_aout_set_arch_mach (abfd, arch, machine)
 #ifndef MY_bfd_link_hash_table_create
 #define MY_bfd_link_hash_table_create NAME(aout,link_hash_table_create)
 #endif
+#ifndef MY_bfd_link_hash_table_free
+#define MY_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
+#endif
 #ifndef MY_bfd_link_add_symbols
 #define MY_bfd_link_add_symbols NAME(aout,link_add_symbols)
 #endif
+#ifndef MY_bfd_link_just_syms
+#define MY_bfd_link_just_syms _bfd_generic_link_just_syms
+#endif
 #ifndef MY_bfd_link_split_section
 #define MY_bfd_link_split_section  _bfd_generic_link_split_section
 #endif
diff --git a/contrib/binutils/bfd/aoutx.h b/contrib/binutils/bfd/aoutx.h
index 83e9732..70359d6 100644
--- a/contrib/binutils/bfd/aoutx.h
+++ b/contrib/binutils/bfd/aoutx.h
@@ -2259,8 +2259,8 @@ NAME(aout,swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
   /* now the fun stuff */
   if (bfd_header_big_endian (abfd))
     {
-      r_index = ((bytes->r_index[0] << 16)
-		 | (bytes->r_index[1] << 8)
+      r_index = (((unsigned int) bytes->r_index[0] << 16)
+		 | ((unsigned int) bytes->r_index[1] << 8)
 		 | bytes->r_index[2]);
       r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
       r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
@@ -2268,8 +2268,8 @@ NAME(aout,swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
     }
   else
     {
-      r_index =  ((bytes->r_index[2] << 16)
-		  | (bytes->r_index[1] << 8)
+      r_index =  (((unsigned int) bytes->r_index[2] << 16)
+		  | ((unsigned int) bytes->r_index[1] << 8)
 		  | bytes->r_index[0]);
       r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
       r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
@@ -2281,9 +2281,9 @@ NAME(aout,swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
   /* Base relative relocs are always against the symbol table,
      regardless of the setting of r_extern.  r_extern just reflects
      whether the symbol the reloc is against is local or global.  */
-  if (r_type == RELOC_BASE10
-      || r_type == RELOC_BASE13
-      || r_type == RELOC_BASE22)
+  if (r_type == (unsigned int) RELOC_BASE10
+      || r_type == (unsigned int) RELOC_BASE13
+      || r_type == (unsigned int) RELOC_BASE22)
     r_extern = 1;
 
   if (r_extern && r_index > symcount)
@@ -2318,8 +2318,8 @@ NAME(aout,swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
   /* now the fun stuff */
   if (bfd_header_big_endian (abfd))
     {
-      r_index = ((bytes->r_index[0] << 16)
-		 | (bytes->r_index[1] << 8)
+      r_index = (((unsigned int) bytes->r_index[0] << 16)
+		 | ((unsigned int) bytes->r_index[1] << 8)
 		 | bytes->r_index[2]);
       r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
       r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
@@ -2331,8 +2331,8 @@ NAME(aout,swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
     }
   else
     {
-      r_index = ((bytes->r_index[2] << 16)
-		 | (bytes->r_index[1] << 8)
+      r_index = (((unsigned int) bytes->r_index[2] << 16)
+		 | ((unsigned int) bytes->r_index[1] << 8)
 		 | bytes->r_index[0]);
       r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
       r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
@@ -3863,7 +3863,7 @@ NAME(aout,final_link) (abfd, info, callback)
       for (p = o->link_order_head; p != NULL; p = p->next)
 	{
 	  if (p->type == bfd_indirect_link_order)
-	    p->u.indirect.section->linker_mark = true;
+	    p->u.indirect.section->linker_mark = (unsigned int) true;
 	}
     }
 
@@ -4412,7 +4412,7 @@ aout_link_write_symbols (finfo, input_bfd)
 	     characters in the symbol names, not including the file
 	     numbers in types (the first number after an open
 	     parenthesis).  */
-	  if (type == N_BINCL)
+	  if (type == (int) N_BINCL)
 	    {
 	      struct external_nlist *incl_sym;
 	      int nest;
@@ -4426,13 +4426,13 @@ aout_link_write_symbols (finfo, input_bfd)
 		  int incl_type;
 
 		  incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
-		  if (incl_type == N_EINCL)
+		  if (incl_type == (int) N_EINCL)
 		    {
 		      if (nest == 0)
 			break;
 		      --nest;
 		    }
-		  else if (incl_type == N_BINCL)
+		  else if (incl_type == (int) N_BINCL)
 		    ++nest;
 		  else if (nest == 0)
 		    {
@@ -4457,7 +4457,7 @@ aout_link_write_symbols (finfo, input_bfd)
 	      /* If we have already included a header file with the
                  same value, then replace this one with an N_EXCL
                  symbol.  */
-	      copy = ! finfo->info->keep_memory;
+	      copy = (boolean) (! finfo->info->keep_memory);
 	      incl_entry = aout_link_includes_lookup (&finfo->includes,
 						      name, true, copy);
 	      if (incl_entry == NULL)
@@ -4485,7 +4485,7 @@ aout_link_write_symbols (finfo, input_bfd)
 		  /* This is a duplicate header file.  We must change
                      it to be an N_EXCL entry, and mark all the
                      included symbols to prevent outputting them.  */
-		  type = N_EXCL;
+		  type = (int) N_EXCL;
 
 		  nest = 0;
 		  for (incl_sym = sym + 1, incl_map = symbol_map + 1;
@@ -4495,7 +4495,7 @@ aout_link_write_symbols (finfo, input_bfd)
 		      int incl_type;
 
 		      incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
-		      if (incl_type == N_EINCL)
+		      if (incl_type == (int) N_EINCL)
 			{
 			  if (nest == 0)
 			    {
@@ -4504,7 +4504,7 @@ aout_link_write_symbols (finfo, input_bfd)
 			    }
 			  --nest;
 			}
-		      else if (incl_type == N_BINCL)
+		      else if (incl_type == (int) N_BINCL)
 			++nest;
 		      else if (nest == 0)
 			*incl_map = -1;
@@ -4859,8 +4859,8 @@ aout_link_input_section_std (finfo, input_bfd, input_section, relocs,
 
 	if (bfd_header_big_endian (input_bfd))
 	  {
-	    r_index   =  ((rel->r_index[0] << 16)
-			  | (rel->r_index[1] << 8)
+	    r_index   =  (((unsigned int) rel->r_index[0] << 16)
+			  | ((unsigned int) rel->r_index[1] << 8)
 			  | rel->r_index[2]);
 	    r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
 	    r_pcrel   = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
@@ -4872,8 +4872,8 @@ aout_link_input_section_std (finfo, input_bfd, input_section, relocs,
 	  }
 	else
 	  {
-	    r_index   = ((rel->r_index[2] << 16)
-			 | (rel->r_index[1] << 8)
+	    r_index   = (((unsigned int) rel->r_index[2] << 16)
+			 | ((unsigned int) rel->r_index[1] << 8)
 			 | rel->r_index[0]);
 	    r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
 	    r_pcrel   = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
@@ -5195,8 +5195,8 @@ aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
 
       if (bfd_header_big_endian (input_bfd))
 	{
-	  r_index  = ((rel->r_index[0] << 16)
-		      | (rel->r_index[1] << 8)
+	  r_index  = (((unsigned int) rel->r_index[0] << 16)
+		      | ((unsigned int) rel->r_index[1] << 8)
 		      | rel->r_index[2]);
 	  r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
 	  r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
@@ -5204,8 +5204,8 @@ aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
 	}
       else
 	{
-	  r_index  = ((rel->r_index[2] << 16)
-		      | (rel->r_index[1] << 8)
+	  r_index  = (((unsigned int) rel->r_index[2] << 16)
+		      | ((unsigned int) rel->r_index[1] << 8)
 		      | rel->r_index[0]);
 	  r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
 	  r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
@@ -5221,16 +5221,16 @@ aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
 	  /* We are generating a relocateable output file, and must
 	     modify the reloc accordingly.  */
 	  if (r_extern
-	      || r_type == RELOC_BASE10
-	      || r_type == RELOC_BASE13
-	      || r_type == RELOC_BASE22)
+	      || r_type == (unsigned int) RELOC_BASE10
+	      || r_type == (unsigned int) RELOC_BASE13
+	      || r_type == (unsigned int) RELOC_BASE22)
 	    {
 	      /* If we know the symbol this relocation is against,
 		 convert it into a relocation against a section.  This
 		 is what the native linker does.  */
-	      if (r_type == RELOC_BASE10
-		  || r_type == RELOC_BASE13
-		  || r_type == RELOC_BASE22)
+	      if (r_type == (unsigned int) RELOC_BASE10
+		  || r_type == (unsigned int) RELOC_BASE13
+		  || r_type == (unsigned int) RELOC_BASE22)
 		h = NULL;
 	      else
 		h = sym_hashes[r_index];
@@ -5398,9 +5398,9 @@ aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
 		  relocation = 0;
 		}
 	    }
-	  else if (r_type == RELOC_BASE10
-		   || r_type == RELOC_BASE13
-		   || r_type == RELOC_BASE22)
+	  else if (r_type == (unsigned int) RELOC_BASE10
+		   || r_type == (unsigned int) RELOC_BASE13
+		   || r_type == (unsigned int) RELOC_BASE22)
 	    {
 	      struct external_nlist *sym;
 	      int type;
@@ -5482,9 +5482,9 @@ aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
              to skip this reloc.  */
 	  if (hundef
 	      && ! finfo->info->shared
-	      && r_type != RELOC_BASE10
-	      && r_type != RELOC_BASE13
-	      && r_type != RELOC_BASE22)
+	      && r_type != (unsigned int) RELOC_BASE10
+	      && r_type != (unsigned int) RELOC_BASE13
+	      && r_type != (unsigned int) RELOC_BASE22)
 	    {
 	      const char *name;
 
@@ -5498,7 +5498,7 @@ aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
 		return false;
 	    }
 
-	  if (r_type != RELOC_SPARC_REV32)
+	  if (r_type != (unsigned int) RELOC_SPARC_REV32)
 	    r = MY_final_link_relocate (howto_table_ext + r_type,
 					input_bfd, input_section,
 					contents, r_addr, relocation,
@@ -5527,9 +5527,9 @@ aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
 		    if (h != NULL)
 		      name = h->root.root.string;
 		    else if (r_extern
-			     || r_type == RELOC_BASE10
-			     || r_type == RELOC_BASE13
-			     || r_type == RELOC_BASE22)
+			     || r_type == (unsigned int) RELOC_BASE10
+			     || r_type == (unsigned int) RELOC_BASE13
+			     || r_type == (unsigned int) RELOC_BASE22)
 		      name = strings + GET_WORD (input_bfd,
 						 syms[r_index].e_strx);
 		    else
@@ -5645,7 +5645,7 @@ aout_link_reloc_link_order (finfo, o, p)
 	int r_relative;
 	int r_length;
 
-	r_pcrel = howto->pc_relative;
+	r_pcrel = (int) howto->pc_relative;
 	r_baserel = (howto->type & 8) != 0;
 	r_jmptable = (howto->type & 16) != 0;
 	r_relative = (howto->type & 32) != 0;
diff --git a/contrib/binutils/bfd/archive.c b/contrib/binutils/bfd/archive.c
index d7ac214..b051e2a 100644
--- a/contrib/binutils/bfd/archive.c
+++ b/contrib/binutils/bfd/archive.c
@@ -436,12 +436,12 @@ _bfd_generic_read_ar_hdr_mag (abfd, mag)
 	 spaces, so only look for ' ' if we don't find '/'.  */
 
       char *e;
-      e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
+      e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
       if (e == NULL)
 	{
-	  e = memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
+	  e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
 	  if (e == NULL)
-	    e = memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
+	    e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
 	}
 
       if (e != NULL)
diff --git a/contrib/binutils/bfd/bfd-in.h b/contrib/binutils/bfd/bfd-in.h
index 807a440..f0f8cfd 100644
--- a/contrib/binutils/bfd/bfd-in.h
+++ b/contrib/binutils/bfd/bfd-in.h
@@ -346,7 +346,7 @@ typedef struct sec *sec_ptr;
 
 #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
 
-#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = (boolean)true), true)
+#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = (unsigned int)true), true)
 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
 
diff --git a/contrib/binutils/bfd/bfd-in2.h b/contrib/binutils/bfd/bfd-in2.h
index bad4281..13aa0f9 100644
--- a/contrib/binutils/bfd/bfd-in2.h
+++ b/contrib/binutils/bfd/bfd-in2.h
@@ -352,7 +352,7 @@ typedef struct sec *sec_ptr;
 
 #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
 
-#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = (boolean)true), true)
+#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = (unsigned int)true), true)
 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
 
@@ -3634,7 +3634,7 @@ extern bfd_byte *bfd_get_relocated_section_contents
                  boolean, asymbol **));
 
 boolean
-bfd_alt_mach_code PARAMS ((bfd *abfd, int index));
+bfd_alt_mach_code PARAMS ((bfd *abfd, int alternative));
 
 /* Extracted from archive.c.  */
 symindex
diff --git a/contrib/binutils/bfd/bfd.c b/contrib/binutils/bfd/bfd.c
index cfd7772..8037b12 100644
--- a/contrib/binutils/bfd/bfd.c
+++ b/contrib/binutils/bfd/bfd.c
@@ -1293,10 +1293,10 @@ bfd_record_phdr (abfd, type, flags_valid, flags, at_valid, at,
   m->p_type = type;
   m->p_flags = flags;
   m->p_paddr = at;
-  m->p_flags_valid = flags_valid;
-  m->p_paddr_valid = at_valid;
-  m->includes_filehdr = includes_filehdr;
-  m->includes_phdrs = includes_phdrs;
+  m->p_flags_valid = (unsigned int) flags_valid;
+  m->p_paddr_valid = (unsigned int) at_valid;
+  m->includes_filehdr = (unsigned int) includes_filehdr;
+  m->includes_phdrs = (unsigned int) includes_phdrs;
   m->count = count;
   if (count > 0)
     memcpy (m->sections, secs, count * sizeof (asection *));
diff --git a/contrib/binutils/bfd/binary.c b/contrib/binutils/bfd/binary.c
index fc972b2..7bddabf 100644
--- a/contrib/binutils/bfd/binary.c
+++ b/contrib/binutils/bfd/binary.c
@@ -185,7 +185,7 @@ binary_get_symtab (abfd, alocation)
 
   syms = (asymbol *) bfd_alloc (abfd, amt);
   if (syms == NULL)
-    return false;
+    return (long) false;
 
   /* Start symbol.  */
   syms[0].the_bfd = abfd;
diff --git a/contrib/binutils/bfd/coff-arm.c b/contrib/binutils/bfd/coff-arm.c
index 5e7f907..25256a8 100644
--- a/contrib/binutils/bfd/coff-arm.c
+++ b/contrib/binutils/bfd/coff-arm.c
@@ -1881,6 +1881,7 @@ record_arm_to_thumb_glue (info, h)
   register asection *               s;
   char *                            tmp_name;
   struct coff_link_hash_entry *     myh;
+  struct bfd_link_hash_entry *      bh;
   struct coff_arm_link_hash_table * globals;
   bfd_vma val;
   bfd_size_type amt;
@@ -1915,10 +1916,10 @@ record_arm_to_thumb_glue (info, h)
      though the section isn't allocated yet, this is where we will be putting
      it.  */
 
+  bh = NULL;
   val = globals->arm_glue_size + 1;
   bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
-				BSF_GLOBAL, s, val, NULL, true, false,
-				(struct bfd_link_hash_entry **) & myh);
+				BSF_GLOBAL, s, val, NULL, true, false, &bh);
 
   free (tmp_name);
 
@@ -1937,6 +1938,7 @@ record_thumb_to_arm_glue (info, h)
   register asection *                s;
   char *                             tmp_name;
   struct coff_link_hash_entry *      myh;
+  struct bfd_link_hash_entry *       bh;
   struct coff_arm_link_hash_table *  globals;
   bfd_vma val;
   bfd_size_type amt;
@@ -1967,12 +1969,13 @@ record_thumb_to_arm_glue (info, h)
       return; /* we've already seen this guy */
     }
 
+  bh = NULL;
   val = globals->thumb_glue_size + 1;
   bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
-				BSF_GLOBAL, s, val, NULL, true, false,
-				(struct bfd_link_hash_entry **) &myh);
+				BSF_GLOBAL, s, val, NULL, true, false, &bh);
 
   /* If we mark it 'thumb', the disassembler will do a better job.  */
+  myh = (struct coff_link_hash_entry *) bh;
   myh->class = C_THUMBEXTFUNC;
 
   free (tmp_name);
@@ -1989,11 +1992,10 @@ record_thumb_to_arm_glue (info, h)
 
   sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
 
-  myh = NULL;
+  bh = NULL;
   val = globals->thumb_glue_size + (globals->support_old_code ? 8 : 4);
   bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
-				BSF_LOCAL, s, val, NULL, true, false,
-				(struct bfd_link_hash_entry **) & myh);
+				BSF_LOCAL, s, val, NULL, true, false, &bh);
 
   free (tmp_name);
 
diff --git a/contrib/binutils/bfd/coff-sh.c b/contrib/binutils/bfd/coff-sh.c
new file mode 100644
index 0000000..d1dc4fd
--- /dev/null
+++ b/contrib/binutils/bfd/coff-sh.c
@@ -0,0 +1,3343 @@
+/* BFD back-end for Hitachi Super-H COFF binaries.
+   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+   Free Software Foundation, Inc.
+   Contributed by Cygnus Support.
+   Written by Steve Chamberlain, <sac@cygnus.com>.
+   Relaxing code written by Ian Lance Taylor, <ian@cygnus.com>.
+
+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 "libiberty.h"
+#include "libbfd.h"
+#include "bfdlink.h"
+#include "coff/sh.h"
+#include "coff/internal.h"
+
+#ifdef COFF_WITH_PE
+#include "coff/pe.h"
+
+#ifndef COFF_IMAGE_WITH_PE
+static boolean sh_align_load_span
+  PARAMS ((bfd *, asection *, bfd_byte *,
+	   boolean (*) (bfd *, asection *, PTR, bfd_byte *, bfd_vma),
+	   PTR, bfd_vma **, bfd_vma *, bfd_vma, bfd_vma, boolean *));
+
+#define _bfd_sh_align_load_span sh_align_load_span
+#endif
+#endif
+
+#include "libcoff.h"
+
+/* Internal functions.  */
+static bfd_reloc_status_type sh_reloc
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static long get_symbol_value PARAMS ((asymbol *));
+static boolean sh_relax_section
+  PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
+static boolean sh_relax_delete_bytes
+  PARAMS ((bfd *, asection *, bfd_vma, int));
+#ifndef COFF_IMAGE_WITH_PE
+static const struct sh_opcode *sh_insn_info PARAMS ((unsigned int));
+#endif
+static boolean sh_align_loads
+  PARAMS ((bfd *, asection *, struct internal_reloc *, bfd_byte *, boolean *));
+static boolean sh_swap_insns
+  PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
+static boolean sh_relocate_section
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+	   struct internal_reloc *, struct internal_syment *, asection **));
+static bfd_byte *sh_coff_get_relocated_section_contents
+  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
+	   bfd_byte *, boolean, asymbol **));
+static reloc_howto_type * sh_coff_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
+
+#ifdef COFF_WITH_PE
+/* Can't build import tables with 2**4 alignment.  */
+#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER	2
+#else
+/* Default section alignment to 2**4.  */
+#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER	4
+#endif
+
+#ifdef COFF_IMAGE_WITH_PE
+/* Align PE executables.  */
+#define COFF_PAGE_SIZE 0x1000
+#endif
+
+/* Generate long file names.  */
+#define COFF_LONG_FILENAMES
+
+#ifdef COFF_WITH_PE
+static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
+/* Return true if this relocation should
+   appear in the output .reloc section.  */
+static boolean in_reloc_p (abfd, howto)
+     bfd * abfd ATTRIBUTE_UNUSED;
+     reloc_howto_type * howto;
+{
+  return ! howto->pc_relative && howto->type != R_SH_IMAGEBASE;
+}
+#endif
+
+/* The supported relocations.  There are a lot of relocations defined
+   in coff/internal.h which we do not expect to ever see.  */
+static reloc_howto_type sh_coff_howtos[] =
+{
+  EMPTY_HOWTO (0),
+  EMPTY_HOWTO (1),
+#ifdef COFF_WITH_PE
+  /* Windows CE */
+  HOWTO (R_SH_IMM32CE,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_imm32ce",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+#else
+  EMPTY_HOWTO (2),
+#endif
+  EMPTY_HOWTO (3), /* R_SH_PCREL8 */
+  EMPTY_HOWTO (4), /* R_SH_PCREL16 */
+  EMPTY_HOWTO (5), /* R_SH_HIGH8 */
+  EMPTY_HOWTO (6), /* R_SH_IMM24 */
+  EMPTY_HOWTO (7), /* R_SH_LOW16 */
+  EMPTY_HOWTO (8),
+  EMPTY_HOWTO (9), /* R_SH_PCDISP8BY4 */
+
+  HOWTO (R_SH_PCDISP8BY2,	/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_pcdisp8by2",	/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  EMPTY_HOWTO (11), /* R_SH_PCDISP8 */
+
+  HOWTO (R_SH_PCDISP,		/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 12,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_pcdisp12by2",	/* name */
+	 true,			/* partial_inplace */
+	 0xfff,			/* src_mask */
+	 0xfff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  EMPTY_HOWTO (13),
+
+  HOWTO (R_SH_IMM32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_imm32",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  EMPTY_HOWTO (15),
+#ifdef COFF_WITH_PE
+  HOWTO (R_SH_IMAGEBASE,        /* type */
+	 0,	                /* rightshift */
+	 2,	                /* size (0 = byte, 1 = short, 2 = long) */
+	 32,	                /* bitsize */
+	 false,	                /* pc_relative */
+	 0,	                /* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,       	/* special_function */
+	 "rva32",	        /* name */
+	 true,	                /* partial_inplace */
+	 0xffffffff,            /* src_mask */
+	 0xffffffff,            /* dst_mask */
+	 false),                /* pcrel_offset */
+#else
+  EMPTY_HOWTO (16), /* R_SH_IMM8 */
+#endif
+  EMPTY_HOWTO (17), /* R_SH_IMM8BY2 */
+  EMPTY_HOWTO (18), /* R_SH_IMM8BY4 */
+  EMPTY_HOWTO (19), /* R_SH_IMM4 */
+  EMPTY_HOWTO (20), /* R_SH_IMM4BY2 */
+  EMPTY_HOWTO (21), /* R_SH_IMM4BY4 */
+
+  HOWTO (R_SH_PCRELIMM8BY2,	/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_pcrelimm8by2",	/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  HOWTO (R_SH_PCRELIMM8BY4,	/* type */
+	 2,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_pcrelimm8by4",	/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  HOWTO (R_SH_IMM16,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_imm16",		/* name */
+	 true,			/* partial_inplace */
+	 0xffff,		/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_SWITCH16,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_switch16",		/* name */
+	 true,			/* partial_inplace */
+	 0xffff,		/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_SWITCH32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_switch32",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_USES,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_uses",		/* name */
+	 true,			/* partial_inplace */
+	 0xffff,		/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_COUNT,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_count",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_ALIGN,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_align",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_CODE,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_code",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_DATA,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_data",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_LABEL,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_label",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_SWITCH8,		/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_reloc,		/* special_function */
+	 "r_switch8",		/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 false)			/* pcrel_offset */
+};
+
+#define SH_COFF_HOWTO_COUNT (sizeof sh_coff_howtos / sizeof sh_coff_howtos[0])
+
+/* Check for a bad magic number.  */
+#define BADMAG(x) SHBADMAG(x)
+
+/* Customize coffcode.h (this is not currently used).  */
+#define SH 1
+
+/* FIXME: This should not be set here.  */
+#define __A_MAGIC_SET__
+
+#ifndef COFF_WITH_PE
+/* Swap the r_offset field in and out.  */
+#define SWAP_IN_RELOC_OFFSET  H_GET_32
+#define SWAP_OUT_RELOC_OFFSET H_PUT_32
+
+/* Swap out extra information in the reloc structure.  */
+#define SWAP_OUT_RELOC_EXTRA(abfd, src, dst)	\
+  do						\
+    {						\
+      dst->r_stuff[0] = 'S';			\
+      dst->r_stuff[1] = 'C';			\
+    }						\
+  while (0)
+#endif
+
+/* Get the value of a symbol, when performing a relocation.  */
+
+static long
+get_symbol_value (symbol)
+     asymbol *symbol;
+{
+  bfd_vma relocation;
+
+  if (bfd_is_com_section (symbol->section))
+    relocation = 0;
+  else
+    relocation = (symbol->value +
+		  symbol->section->output_section->vma +
+		  symbol->section->output_offset);
+
+  return relocation;
+}
+
+#ifdef COFF_WITH_PE
+/* Convert an rtype to howto for the COFF backend linker.
+   Copied from coff-i386.  */
+#define coff_rtype_to_howto coff_sh_rtype_to_howto
+static reloc_howto_type * coff_sh_rtype_to_howto PARAMS ((bfd *, asection *, struct internal_reloc *, struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *));
+
+static reloc_howto_type *
+coff_sh_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
+     bfd * abfd ATTRIBUTE_UNUSED;
+     asection * sec;
+     struct internal_reloc * rel;
+     struct coff_link_hash_entry * h;
+     struct internal_syment * sym;
+     bfd_vma * addendp;
+{
+  reloc_howto_type * howto;
+
+  howto = sh_coff_howtos + rel->r_type;
+
+  *addendp = 0;
+
+  if (howto->pc_relative)
+    *addendp += sec->vma;
+
+  if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
+    {
+      /* This is a common symbol.  The section contents include the
+	 size (sym->n_value) as an addend.  The relocate_section
+	 function will be adding in the final value of the symbol.  We
+	 need to subtract out the current size in order to get the
+	 correct result.  */
+      BFD_ASSERT (h != NULL);
+    }
+
+  if (howto->pc_relative)
+    {
+      *addendp -= 4;
+
+      /* If the symbol is defined, then the generic code is going to
+         add back the symbol value in order to cancel out an
+         adjustment it made to the addend.  However, we set the addend
+         to 0 at the start of this function.  We need to adjust here,
+         to avoid the adjustment the generic code will make.  FIXME:
+         This is getting a bit hackish.  */
+      if (sym != NULL && sym->n_scnum != 0)
+	*addendp -= sym->n_value;
+    }
+
+  if (rel->r_type == R_SH_IMAGEBASE)
+    *addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
+
+  return howto;
+}
+
+#endif /* COFF_WITH_PE */
+
+/* This structure is used to map BFD reloc codes to SH PE relocs.  */
+struct shcoff_reloc_map
+{
+  bfd_reloc_code_real_type bfd_reloc_val;
+  unsigned char shcoff_reloc_val;
+};
+
+#ifdef COFF_WITH_PE
+/* An array mapping BFD reloc codes to SH PE relocs.  */
+static const struct shcoff_reloc_map sh_reloc_map[] =
+{
+  { BFD_RELOC_32, R_SH_IMM32CE },
+  { BFD_RELOC_RVA, R_SH_IMAGEBASE },
+  { BFD_RELOC_CTOR, R_SH_IMM32CE },
+};
+#else
+/* An array mapping BFD reloc codes to SH PE relocs.  */
+static const struct shcoff_reloc_map sh_reloc_map[] =
+{
+  { BFD_RELOC_32, R_SH_IMM32 },
+  { BFD_RELOC_CTOR, R_SH_IMM32 },
+};
+#endif
+
+/* Given a BFD reloc code, return the howto structure for the
+   corresponding SH PE reloc.  */
+#define coff_bfd_reloc_type_lookup	sh_coff_reloc_type_lookup
+
+static reloc_howto_type *
+sh_coff_reloc_type_lookup (abfd, code)
+     bfd * abfd ATTRIBUTE_UNUSED;
+     bfd_reloc_code_real_type code;
+{
+  unsigned int i;
+
+  for (i = ARRAY_SIZE (sh_reloc_map); i--;)
+    if (sh_reloc_map[i].bfd_reloc_val == code)
+      return &sh_coff_howtos[(int) sh_reloc_map[i].shcoff_reloc_val];
+
+  fprintf (stderr, "SH Error: unknown reloc type %d\n", code);
+  return NULL;
+}
+
+/* This macro is used in coffcode.h to get the howto corresponding to
+   an internal reloc.  */
+
+#define RTYPE2HOWTO(relent, internal)		\
+  ((relent)->howto =				\
+   ((internal)->r_type < SH_COFF_HOWTO_COUNT	\
+    ? &sh_coff_howtos[(internal)->r_type]	\
+    : (reloc_howto_type *) NULL))
+
+/* This is the same as the macro in coffcode.h, except that it copies
+   r_offset into reloc_entry->addend for some relocs.  */
+#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
+  {                                                             \
+    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
+    if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
+      coffsym = (obj_symbols (abfd)                             \
+                 + (cache_ptr->sym_ptr_ptr - symbols));         \
+    else if (ptr)                                               \
+      coffsym = coff_symbol_from (abfd, ptr);                   \
+    if (coffsym != (coff_symbol_type *) NULL                    \
+        && coffsym->native->u.syment.n_scnum == 0)              \
+      cache_ptr->addend = 0;                                    \
+    else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
+             && ptr->section != (asection *) NULL)              \
+      cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
+    else                                                        \
+      cache_ptr->addend = 0;                                    \
+    if ((reloc).r_type == R_SH_SWITCH8				\
+	|| (reloc).r_type == R_SH_SWITCH16			\
+	|| (reloc).r_type == R_SH_SWITCH32			\
+	|| (reloc).r_type == R_SH_USES				\
+	|| (reloc).r_type == R_SH_COUNT				\
+	|| (reloc).r_type == R_SH_ALIGN)			\
+      cache_ptr->addend = (reloc).r_offset;			\
+  }
+
+/* This is the howto function for the SH relocations.  */
+
+static bfd_reloc_status_type
+sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
+	  error_message)
+     bfd *abfd;
+     arelent *reloc_entry;
+     asymbol *symbol_in;
+     PTR data;
+     asection *input_section;
+     bfd *output_bfd;
+     char **error_message ATTRIBUTE_UNUSED;
+{
+  unsigned long insn;
+  bfd_vma sym_value;
+  unsigned short r_type;
+  bfd_vma addr = reloc_entry->address;
+  bfd_byte *hit_data = addr + (bfd_byte *) data;
+
+  r_type = reloc_entry->howto->type;
+
+  if (output_bfd != NULL)
+    {
+      /* Partial linking--do nothing.  */
+      reloc_entry->address += input_section->output_offset;
+      return bfd_reloc_ok;
+    }
+
+  /* Almost all relocs have to do with relaxing.  If any work must be
+     done for them, it has been done in sh_relax_section.  */
+  if (r_type != R_SH_IMM32
+#ifdef COFF_WITH_PE
+      && r_type != R_SH_IMM32CE
+      && r_type != R_SH_IMAGEBASE
+#endif
+      && (r_type != R_SH_PCDISP
+	  || (symbol_in->flags & BSF_LOCAL) != 0))
+    return bfd_reloc_ok;
+
+  if (symbol_in != NULL
+      && bfd_is_und_section (symbol_in->section))
+    return bfd_reloc_undefined;
+
+  sym_value = get_symbol_value (symbol_in);
+
+  switch (r_type)
+    {
+    case R_SH_IMM32:
+#ifdef COFF_WITH_PE
+    case R_SH_IMM32CE:
+#endif
+      insn = bfd_get_32 (abfd, hit_data);
+      insn += sym_value + reloc_entry->addend;
+      bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
+      break;
+#ifdef COFF_WITH_PE
+    case R_SH_IMAGEBASE:
+      insn = bfd_get_32 (abfd, hit_data);
+      insn += sym_value + reloc_entry->addend;
+      insn -= pe_data (input_section->output_section->owner)->pe_opthdr.ImageBase;
+      bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
+      break;
+#endif
+    case R_SH_PCDISP:
+      insn = bfd_get_16 (abfd, hit_data);
+      sym_value += reloc_entry->addend;
+      sym_value -= (input_section->output_section->vma
+		    + input_section->output_offset
+		    + addr
+		    + 4);
+      sym_value += (insn & 0xfff) << 1;
+      if (insn & 0x800)
+	sym_value -= 0x1000;
+      insn = (insn & 0xf000) | (sym_value & 0xfff);
+      bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
+      if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
+	return bfd_reloc_overflow;
+      break;
+    default:
+      abort ();
+      break;
+    }
+
+  return bfd_reloc_ok;
+}
+
+#define coff_bfd_merge_private_bfd_data _bfd_generic_verify_endian_match
+
+/* We can do relaxing.  */
+#define coff_bfd_relax_section sh_relax_section
+
+/* We use the special COFF backend linker.  */
+#define coff_relocate_section sh_relocate_section
+
+/* When relaxing, we need to use special code to get the relocated
+   section contents.  */
+#define coff_bfd_get_relocated_section_contents \
+  sh_coff_get_relocated_section_contents
+
+#include "coffcode.h"
+
+/* This function handles relaxing on the SH.
+
+   Function calls on the SH look like this:
+
+       movl  L1,r0
+       ...
+       jsr   @r0
+       ...
+     L1:
+       .long function
+
+   The compiler and assembler will cooperate to create R_SH_USES
+   relocs on the jsr instructions.  The r_offset field of the
+   R_SH_USES reloc is the PC relative offset to the instruction which
+   loads the register (the r_offset field is computed as though it
+   were a jump instruction, so the offset value is actually from four
+   bytes past the instruction).  The linker can use this reloc to
+   determine just which function is being called, and thus decide
+   whether it is possible to replace the jsr with a bsr.
+
+   If multiple function calls are all based on a single register load
+   (i.e., the same function is called multiple times), the compiler
+   guarantees that each function call will have an R_SH_USES reloc.
+   Therefore, if the linker is able to convert each R_SH_USES reloc
+   which refers to that address, it can safely eliminate the register
+   load.
+
+   When the assembler creates an R_SH_USES reloc, it examines it to
+   determine which address is being loaded (L1 in the above example).
+   It then counts the number of references to that address, and
+   creates an R_SH_COUNT reloc at that address.  The r_offset field of
+   the R_SH_COUNT reloc will be the number of references.  If the
+   linker is able to eliminate a register load, it can use the
+   R_SH_COUNT reloc to see whether it can also eliminate the function
+   address.
+
+   SH relaxing also handles another, unrelated, matter.  On the SH, if
+   a load or store instruction is not aligned on a four byte boundary,
+   the memory cycle interferes with the 32 bit instruction fetch,
+   causing a one cycle bubble in the pipeline.  Therefore, we try to
+   align load and store instructions on four byte boundaries if we
+   can, by swapping them with one of the adjacent instructions.  */
+
+static boolean
+sh_relax_section (abfd, sec, link_info, again)
+     bfd *abfd;
+     asection *sec;
+     struct bfd_link_info *link_info;
+     boolean *again;
+{
+  struct internal_reloc *internal_relocs;
+  struct internal_reloc *free_relocs = NULL;
+  boolean have_code;
+  struct internal_reloc *irel, *irelend;
+  bfd_byte *contents = NULL;
+  bfd_byte *free_contents = NULL;
+
+  *again = false;
+
+  if (link_info->relocateable
+      || (sec->flags & SEC_RELOC) == 0
+      || sec->reloc_count == 0)
+    return true;
+
+  /* If this is the first time we have been called for this section,
+     initialize the cooked size.  */
+  if (sec->_cooked_size == 0)
+    sec->_cooked_size = sec->_raw_size;
+
+  internal_relocs = (_bfd_coff_read_internal_relocs
+		     (abfd, sec, link_info->keep_memory,
+		      (bfd_byte *) NULL, false,
+		      (struct internal_reloc *) NULL));
+  if (internal_relocs == NULL)
+    goto error_return;
+  if (! link_info->keep_memory)
+    free_relocs = internal_relocs;
+
+  have_code = false;
+
+  irelend = internal_relocs + sec->reloc_count;
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      bfd_vma laddr, paddr, symval;
+      unsigned short insn;
+      struct internal_reloc *irelfn, *irelscan, *irelcount;
+      struct internal_syment sym;
+      bfd_signed_vma foff;
+
+      if (irel->r_type == R_SH_CODE)
+	have_code = true;
+
+      if (irel->r_type != R_SH_USES)
+	continue;
+
+      /* Get the section contents.  */
+      if (contents == NULL)
+	{
+	  if (coff_section_data (abfd, sec) != NULL
+	      && coff_section_data (abfd, sec)->contents != NULL)
+	    contents = coff_section_data (abfd, sec)->contents;
+	  else
+	    {
+	      contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
+	      if (contents == NULL)
+		goto error_return;
+	      free_contents = contents;
+
+	      if (! bfd_get_section_contents (abfd, sec, contents,
+					      (file_ptr) 0, sec->_raw_size))
+		goto error_return;
+	    }
+	}
+
+      /* The r_offset field of the R_SH_USES reloc will point us to
+         the register load.  The 4 is because the r_offset field is
+         computed as though it were a jump offset, which are based
+         from 4 bytes after the jump instruction.  */
+      laddr = irel->r_vaddr - sec->vma + 4;
+      /* Careful to sign extend the 32-bit offset.  */
+      laddr += ((irel->r_offset & 0xffffffff) ^ 0x80000000) - 0x80000000;
+      if (laddr >= sec->_raw_size)
+	{
+	  (*_bfd_error_handler) ("%s: 0x%lx: warning: bad R_SH_USES offset",
+				 bfd_archive_filename (abfd),
+				 (unsigned long) irel->r_vaddr);
+	  continue;
+	}
+      insn = bfd_get_16 (abfd, contents + laddr);
+
+      /* If the instruction is not mov.l NN,rN, we don't know what to do.  */
+      if ((insn & 0xf000) != 0xd000)
+	{
+	  ((*_bfd_error_handler)
+	   ("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x",
+	    bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr, insn));
+	  continue;
+	}
+
+      /* Get the address from which the register is being loaded.  The
+      	 displacement in the mov.l instruction is quadrupled.  It is a
+      	 displacement from four bytes after the movl instruction, but,
+      	 before adding in the PC address, two least significant bits
+      	 of the PC are cleared.  We assume that the section is aligned
+      	 on a four byte boundary.  */
+      paddr = insn & 0xff;
+      paddr *= 4;
+      paddr += (laddr + 4) &~ (bfd_vma) 3;
+      if (paddr >= sec->_raw_size)
+	{
+	  ((*_bfd_error_handler)
+	   ("%s: 0x%lx: warning: bad R_SH_USES load offset",
+	    bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr));
+	  continue;
+	}
+
+      /* Get the reloc for the address from which the register is
+         being loaded.  This reloc will tell us which function is
+         actually being called.  */
+      paddr += sec->vma;
+      for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
+	if (irelfn->r_vaddr == paddr
+#ifdef COFF_WITH_PE
+	    && (irelfn->r_type == R_SH_IMM32
+		|| irelfn->r_type == R_SH_IMM32CE
+		|| irelfn->r_type == R_SH_IMAGEBASE))
+
+#else
+	    && irelfn->r_type == R_SH_IMM32)
+#endif
+	  break;
+      if (irelfn >= irelend)
+	{
+	  ((*_bfd_error_handler)
+	   ("%s: 0x%lx: warning: could not find expected reloc",
+	    bfd_archive_filename (abfd), (unsigned long) paddr));
+	  continue;
+	}
+
+      /* Get the value of the symbol referred to by the reloc.  */
+      if (! _bfd_coff_get_external_symbols (abfd))
+	goto error_return;
+      bfd_coff_swap_sym_in (abfd,
+			    ((bfd_byte *) obj_coff_external_syms (abfd)
+			     + (irelfn->r_symndx
+				* bfd_coff_symesz (abfd))),
+			    &sym);
+      if (sym.n_scnum != 0 && sym.n_scnum != sec->target_index)
+	{
+	  ((*_bfd_error_handler)
+	   ("%s: 0x%lx: warning: symbol in unexpected section",
+	    bfd_archive_filename (abfd), (unsigned long) paddr));
+	  continue;
+	}
+
+      if (sym.n_sclass != C_EXT)
+	{
+	  symval = (sym.n_value
+		    - sec->vma
+		    + sec->output_section->vma
+		    + sec->output_offset);
+	}
+      else
+	{
+	  struct coff_link_hash_entry *h;
+
+	  h = obj_coff_sym_hashes (abfd)[irelfn->r_symndx];
+	  BFD_ASSERT (h != NULL);
+	  if (h->root.type != bfd_link_hash_defined
+	      && h->root.type != bfd_link_hash_defweak)
+	    {
+	      /* This appears to be a reference to an undefined
+                 symbol.  Just ignore it--it will be caught by the
+                 regular reloc processing.  */
+	      continue;
+	    }
+
+	  symval = (h->root.u.def.value
+		    + h->root.u.def.section->output_section->vma
+		    + h->root.u.def.section->output_offset);
+	}
+
+      symval += bfd_get_32 (abfd, contents + paddr - sec->vma);
+
+      /* See if this function call can be shortened.  */
+      foff = (symval
+	      - (irel->r_vaddr
+		 - sec->vma
+		 + sec->output_section->vma
+		 + sec->output_offset
+		 + 4));
+      if (foff < -0x1000 || foff >= 0x1000)
+	{
+	  /* After all that work, we can't shorten this function call.  */
+	  continue;
+	}
+
+      /* Shorten the function call.  */
+
+      /* For simplicity of coding, we are going to modify the section
+	 contents, the section relocs, and the BFD symbol table.  We
+	 must tell the rest of the code not to free up this
+	 information.  It would be possible to instead create a table
+	 of changes which have to be made, as is done in coff-mips.c;
+	 that would be more work, but would require less memory when
+	 the linker is run.  */
+
+      if (coff_section_data (abfd, sec) == NULL)
+	{
+	  bfd_size_type amt = sizeof (struct coff_section_tdata);
+	  sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+	  if (sec->used_by_bfd == NULL)
+	    goto error_return;
+	}
+
+      coff_section_data (abfd, sec)->relocs = internal_relocs;
+      coff_section_data (abfd, sec)->keep_relocs = true;
+      free_relocs = NULL;
+
+      coff_section_data (abfd, sec)->contents = contents;
+      coff_section_data (abfd, sec)->keep_contents = true;
+      free_contents = NULL;
+
+      obj_coff_keep_syms (abfd) = true;
+
+      /* Replace the jsr with a bsr.  */
+
+      /* Change the R_SH_USES reloc into an R_SH_PCDISP reloc, and
+         replace the jsr with a bsr.  */
+      irel->r_type = R_SH_PCDISP;
+      irel->r_symndx = irelfn->r_symndx;
+      if (sym.n_sclass != C_EXT)
+	{
+	  /* If this needs to be changed because of future relaxing,
+             it will be handled here like other internal PCDISP
+             relocs.  */
+	  bfd_put_16 (abfd,
+		      (bfd_vma) 0xb000 | ((foff >> 1) & 0xfff),
+		      contents + irel->r_vaddr - sec->vma);
+	}
+      else
+	{
+	  /* We can't fully resolve this yet, because the external
+             symbol value may be changed by future relaxing.  We let
+             the final link phase handle it.  */
+	  bfd_put_16 (abfd, (bfd_vma) 0xb000,
+		      contents + irel->r_vaddr - sec->vma);
+	}
+
+      /* See if there is another R_SH_USES reloc referring to the same
+         register load.  */
+      for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
+	if (irelscan->r_type == R_SH_USES
+	    && laddr == irelscan->r_vaddr - sec->vma + 4 + irelscan->r_offset)
+	  break;
+      if (irelscan < irelend)
+	{
+	  /* Some other function call depends upon this register load,
+	     and we have not yet converted that function call.
+	     Indeed, we may never be able to convert it.  There is
+	     nothing else we can do at this point.  */
+	  continue;
+	}
+
+      /* Look for a R_SH_COUNT reloc on the location where the
+         function address is stored.  Do this before deleting any
+         bytes, to avoid confusion about the address.  */
+      for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
+	if (irelcount->r_vaddr == paddr
+	    && irelcount->r_type == R_SH_COUNT)
+	  break;
+
+      /* Delete the register load.  */
+      if (! sh_relax_delete_bytes (abfd, sec, laddr, 2))
+	goto error_return;
+
+      /* That will change things, so, just in case it permits some
+         other function call to come within range, we should relax
+         again.  Note that this is not required, and it may be slow.  */
+      *again = true;
+
+      /* Now check whether we got a COUNT reloc.  */
+      if (irelcount >= irelend)
+	{
+	  ((*_bfd_error_handler)
+	   ("%s: 0x%lx: warning: could not find expected COUNT reloc",
+	    bfd_archive_filename (abfd), (unsigned long) paddr));
+	  continue;
+	}
+
+      /* The number of uses is stored in the r_offset field.  We've
+         just deleted one.  */
+      if (irelcount->r_offset == 0)
+	{
+	  ((*_bfd_error_handler) ("%s: 0x%lx: warning: bad count",
+				  bfd_archive_filename (abfd),
+				  (unsigned long) paddr));
+	  continue;
+	}
+
+      --irelcount->r_offset;
+
+      /* If there are no more uses, we can delete the address.  Reload
+         the address from irelfn, in case it was changed by the
+         previous call to sh_relax_delete_bytes.  */
+      if (irelcount->r_offset == 0)
+	{
+	  if (! sh_relax_delete_bytes (abfd, sec,
+				       irelfn->r_vaddr - sec->vma, 4))
+	    goto error_return;
+	}
+
+      /* We've done all we can with that function call.  */
+    }
+
+  /* Look for load and store instructions that we can align on four
+     byte boundaries.  */
+  if (have_code)
+    {
+      boolean swapped;
+
+      /* Get the section contents.  */
+      if (contents == NULL)
+	{
+	  if (coff_section_data (abfd, sec) != NULL
+	      && coff_section_data (abfd, sec)->contents != NULL)
+	    contents = coff_section_data (abfd, sec)->contents;
+	  else
+	    {
+	      contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
+	      if (contents == NULL)
+		goto error_return;
+	      free_contents = contents;
+
+	      if (! bfd_get_section_contents (abfd, sec, contents,
+					      (file_ptr) 0, sec->_raw_size))
+		goto error_return;
+	    }
+	}
+
+      if (! sh_align_loads (abfd, sec, internal_relocs, contents, &swapped))
+	goto error_return;
+
+      if (swapped)
+	{
+	  if (coff_section_data (abfd, sec) == NULL)
+	    {
+	      bfd_size_type amt = sizeof (struct coff_section_tdata);
+	      sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+	      if (sec->used_by_bfd == NULL)
+		goto error_return;
+	    }
+
+	  coff_section_data (abfd, sec)->relocs = internal_relocs;
+	  coff_section_data (abfd, sec)->keep_relocs = true;
+	  free_relocs = NULL;
+
+	  coff_section_data (abfd, sec)->contents = contents;
+	  coff_section_data (abfd, sec)->keep_contents = true;
+	  free_contents = NULL;
+
+	  obj_coff_keep_syms (abfd) = true;
+	}
+    }
+
+  if (free_relocs != NULL)
+    {
+      free (free_relocs);
+      free_relocs = NULL;
+    }
+
+  if (free_contents != NULL)
+    {
+      if (! link_info->keep_memory)
+	free (free_contents);
+      else
+	{
+	  /* Cache the section contents for coff_link_input_bfd.  */
+	  if (coff_section_data (abfd, sec) == NULL)
+	    {
+	      bfd_size_type amt = sizeof (struct coff_section_tdata);
+	      sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+	      if (sec->used_by_bfd == NULL)
+		goto error_return;
+	      coff_section_data (abfd, sec)->relocs = NULL;
+	    }
+	  coff_section_data (abfd, sec)->contents = contents;
+	}
+    }
+
+  return true;
+
+ error_return:
+  if (free_relocs != NULL)
+    free (free_relocs);
+  if (free_contents != NULL)
+    free (free_contents);
+  return false;
+}
+
+/* Delete some bytes from a section while relaxing.  */
+
+static boolean
+sh_relax_delete_bytes (abfd, sec, addr, count)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma addr;
+     int count;
+{
+  bfd_byte *contents;
+  struct internal_reloc *irel, *irelend;
+  struct internal_reloc *irelalign;
+  bfd_vma toaddr;
+  bfd_byte *esym, *esymend;
+  bfd_size_type symesz;
+  struct coff_link_hash_entry **sym_hash;
+  asection *o;
+
+  contents = coff_section_data (abfd, sec)->contents;
+
+  /* The deletion must stop at the next ALIGN reloc for an aligment
+     power larger than the number of bytes we are deleting.  */
+
+  irelalign = NULL;
+  toaddr = sec->_cooked_size;
+
+  irel = coff_section_data (abfd, sec)->relocs;
+  irelend = irel + sec->reloc_count;
+  for (; irel < irelend; irel++)
+    {
+      if (irel->r_type == R_SH_ALIGN
+	  && irel->r_vaddr - sec->vma > addr
+	  && count < (1 << irel->r_offset))
+	{
+	  irelalign = irel;
+	  toaddr = irel->r_vaddr - sec->vma;
+	  break;
+	}
+    }
+
+  /* Actually delete the bytes.  */
+  memmove (contents + addr, contents + addr + count,
+	   (size_t) (toaddr - addr - count));
+  if (irelalign == NULL)
+    sec->_cooked_size -= count;
+  else
+    {
+      int i;
+
+#define NOP_OPCODE (0x0009)
+
+      BFD_ASSERT ((count & 1) == 0);
+      for (i = 0; i < count; i += 2)
+	bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
+    }
+
+  /* Adjust all the relocs.  */
+  for (irel = coff_section_data (abfd, sec)->relocs; irel < irelend; irel++)
+    {
+      bfd_vma nraddr, stop;
+      bfd_vma start = 0;
+      int insn = 0;
+      struct internal_syment sym;
+      int off, adjust, oinsn;
+      bfd_signed_vma voff = 0;
+      boolean overflow;
+
+      /* Get the new reloc address.  */
+      nraddr = irel->r_vaddr - sec->vma;
+      if ((irel->r_vaddr - sec->vma > addr
+	   && irel->r_vaddr - sec->vma < toaddr)
+	  || (irel->r_type == R_SH_ALIGN
+	      && irel->r_vaddr - sec->vma == toaddr))
+	nraddr -= count;
+
+      /* See if this reloc was for the bytes we have deleted, in which
+	 case we no longer care about it.  Don't delete relocs which
+	 represent addresses, though.  */
+      if (irel->r_vaddr - sec->vma >= addr
+	  && irel->r_vaddr - sec->vma < addr + count
+	  && irel->r_type != R_SH_ALIGN
+	  && irel->r_type != R_SH_CODE
+	  && irel->r_type != R_SH_DATA
+	  && irel->r_type != R_SH_LABEL)
+	irel->r_type = R_SH_UNUSED;
+
+      /* If this is a PC relative reloc, see if the range it covers
+         includes the bytes we have deleted.  */
+      switch (irel->r_type)
+	{
+	default:
+	  break;
+
+	case R_SH_PCDISP8BY2:
+	case R_SH_PCDISP:
+	case R_SH_PCRELIMM8BY2:
+	case R_SH_PCRELIMM8BY4:
+	  start = irel->r_vaddr - sec->vma;
+	  insn = bfd_get_16 (abfd, contents + nraddr);
+	  break;
+	}
+
+      switch (irel->r_type)
+	{
+	default:
+	  start = stop = addr;
+	  break;
+
+	case R_SH_IMM32:
+#ifdef COFF_WITH_PE
+	case R_SH_IMM32CE:
+	case R_SH_IMAGEBASE:
+#endif
+	  /* If this reloc is against a symbol defined in this
+             section, and the symbol will not be adjusted below, we
+             must check the addend to see it will put the value in
+             range to be adjusted, and hence must be changed.  */
+	  bfd_coff_swap_sym_in (abfd,
+				((bfd_byte *) obj_coff_external_syms (abfd)
+				 + (irel->r_symndx
+				    * bfd_coff_symesz (abfd))),
+				&sym);
+	  if (sym.n_sclass != C_EXT
+	      && sym.n_scnum == sec->target_index
+	      && ((bfd_vma) sym.n_value <= addr
+		  || (bfd_vma) sym.n_value >= toaddr))
+	    {
+	      bfd_vma val;
+
+	      val = bfd_get_32 (abfd, contents + nraddr);
+	      val += sym.n_value;
+	      if (val > addr && val < toaddr)
+		bfd_put_32 (abfd, val - count, contents + nraddr);
+	    }
+	  start = stop = addr;
+	  break;
+
+	case R_SH_PCDISP8BY2:
+	  off = insn & 0xff;
+	  if (off & 0x80)
+	    off -= 0x100;
+	  stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
+	  break;
+
+	case R_SH_PCDISP:
+	  bfd_coff_swap_sym_in (abfd,
+				((bfd_byte *) obj_coff_external_syms (abfd)
+				 + (irel->r_symndx
+				    * bfd_coff_symesz (abfd))),
+				&sym);
+	  if (sym.n_sclass == C_EXT)
+	    start = stop = addr;
+	  else
+	    {
+	      off = insn & 0xfff;
+	      if (off & 0x800)
+		off -= 0x1000;
+	      stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
+	    }
+	  break;
+
+	case R_SH_PCRELIMM8BY2:
+	  off = insn & 0xff;
+	  stop = start + 4 + off * 2;
+	  break;
+
+	case R_SH_PCRELIMM8BY4:
+	  off = insn & 0xff;
+	  stop = (start &~ (bfd_vma) 3) + 4 + off * 4;
+	  break;
+
+	case R_SH_SWITCH8:
+	case R_SH_SWITCH16:
+	case R_SH_SWITCH32:
+	  /* These relocs types represent
+	       .word L2-L1
+	     The r_offset field holds the difference between the reloc
+	     address and L1.  That is the start of the reloc, and
+	     adding in the contents gives us the top.  We must adjust
+	     both the r_offset field and the section contents.  */
+
+	  start = irel->r_vaddr - sec->vma;
+	  stop = (bfd_vma) ((bfd_signed_vma) start - (long) irel->r_offset);
+
+	  if (start > addr
+	      && start < toaddr
+	      && (stop <= addr || stop >= toaddr))
+	    irel->r_offset += count;
+	  else if (stop > addr
+		   && stop < toaddr
+		   && (start <= addr || start >= toaddr))
+	    irel->r_offset -= count;
+
+	  start = stop;
+
+	  if (irel->r_type == R_SH_SWITCH16)
+	    voff = bfd_get_signed_16 (abfd, contents + nraddr);
+	  else if (irel->r_type == R_SH_SWITCH8)
+	    voff = bfd_get_8 (abfd, contents + nraddr);
+	  else
+	    voff = bfd_get_signed_32 (abfd, contents + nraddr);
+	  stop = (bfd_vma) ((bfd_signed_vma) start + voff);
+
+	  break;
+
+	case R_SH_USES:
+	  start = irel->r_vaddr - sec->vma;
+	  stop = (bfd_vma) ((bfd_signed_vma) start
+			    + (long) irel->r_offset
+			    + 4);
+	  break;
+	}
+
+      if (start > addr
+	  && start < toaddr
+	  && (stop <= addr || stop >= toaddr))
+	adjust = count;
+      else if (stop > addr
+	       && stop < toaddr
+	       && (start <= addr || start >= toaddr))
+	adjust = - count;
+      else
+	adjust = 0;
+
+      if (adjust != 0)
+	{
+	  oinsn = insn;
+	  overflow = false;
+	  switch (irel->r_type)
+	    {
+	    default:
+	      abort ();
+	      break;
+
+	    case R_SH_PCDISP8BY2:
+	    case R_SH_PCRELIMM8BY2:
+	      insn += adjust / 2;
+	      if ((oinsn & 0xff00) != (insn & 0xff00))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
+	      break;
+
+	    case R_SH_PCDISP:
+	      insn += adjust / 2;
+	      if ((oinsn & 0xf000) != (insn & 0xf000))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
+	      break;
+
+	    case R_SH_PCRELIMM8BY4:
+	      BFD_ASSERT (adjust == count || count >= 4);
+	      if (count >= 4)
+		insn += adjust / 4;
+	      else
+		{
+		  if ((irel->r_vaddr & 3) == 0)
+		    ++insn;
+		}
+	      if ((oinsn & 0xff00) != (insn & 0xff00))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
+	      break;
+
+	    case R_SH_SWITCH8:
+	      voff += adjust;
+	      if (voff < 0 || voff >= 0xff)
+		overflow = true;
+	      bfd_put_8 (abfd, (bfd_vma) voff, contents + nraddr);
+	      break;
+
+	    case R_SH_SWITCH16:
+	      voff += adjust;
+	      if (voff < - 0x8000 || voff >= 0x8000)
+		overflow = true;
+	      bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
+	      break;
+
+	    case R_SH_SWITCH32:
+	      voff += adjust;
+	      bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
+	      break;
+
+	    case R_SH_USES:
+	      irel->r_offset += adjust;
+	      break;
+	    }
+
+	  if (overflow)
+	    {
+	      ((*_bfd_error_handler)
+	       ("%s: 0x%lx: fatal: reloc overflow while relaxing",
+		bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr));
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+	}
+
+      irel->r_vaddr = nraddr + sec->vma;
+    }
+
+  /* Look through all the other sections.  If there contain any IMM32
+     relocs against internal symbols which we are not going to adjust
+     below, we may need to adjust the addends.  */
+  for (o = abfd->sections; o != NULL; o = o->next)
+    {
+      struct internal_reloc *internal_relocs;
+      struct internal_reloc *irelscan, *irelscanend;
+      bfd_byte *ocontents;
+
+      if (o == sec
+	  || (o->flags & SEC_RELOC) == 0
+	  || o->reloc_count == 0)
+	continue;
+
+      /* We always cache the relocs.  Perhaps, if info->keep_memory is
+         false, we should free them, if we are permitted to, when we
+         leave sh_coff_relax_section.  */
+      internal_relocs = (_bfd_coff_read_internal_relocs
+			 (abfd, o, true, (bfd_byte *) NULL, false,
+			  (struct internal_reloc *) NULL));
+      if (internal_relocs == NULL)
+	return false;
+
+      ocontents = NULL;
+      irelscanend = internal_relocs + o->reloc_count;
+      for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
+	{
+	  struct internal_syment sym;
+
+#ifdef COFF_WITH_PE
+	  if (irelscan->r_type != R_SH_IMM32
+	      && irelscan->r_type != R_SH_IMAGEBASE
+	      && irelscan->r_type != R_SH_IMM32CE)
+#else
+	  if (irelscan->r_type != R_SH_IMM32)
+#endif
+	    continue;
+
+	  bfd_coff_swap_sym_in (abfd,
+				((bfd_byte *) obj_coff_external_syms (abfd)
+				 + (irelscan->r_symndx
+				    * bfd_coff_symesz (abfd))),
+				&sym);
+	  if (sym.n_sclass != C_EXT
+	      && sym.n_scnum == sec->target_index
+	      && ((bfd_vma) sym.n_value <= addr
+		  || (bfd_vma) sym.n_value >= toaddr))
+	    {
+	      bfd_vma val;
+
+	      if (ocontents == NULL)
+		{
+		  if (coff_section_data (abfd, o)->contents != NULL)
+		    ocontents = coff_section_data (abfd, o)->contents;
+		  else
+		    {
+		      /* We always cache the section contents.
+                         Perhaps, if info->keep_memory is false, we
+                         should free them, if we are permitted to,
+                         when we leave sh_coff_relax_section.  */
+		      ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
+		      if (ocontents == NULL)
+			return false;
+		      if (! bfd_get_section_contents (abfd, o, ocontents,
+						      (file_ptr) 0,
+						      o->_raw_size))
+			return false;
+		      coff_section_data (abfd, o)->contents = ocontents;
+		    }
+		}
+
+	      val = bfd_get_32 (abfd, ocontents + irelscan->r_vaddr - o->vma);
+	      val += sym.n_value;
+	      if (val > addr && val < toaddr)
+		bfd_put_32 (abfd, val - count,
+			    ocontents + irelscan->r_vaddr - o->vma);
+
+	      coff_section_data (abfd, o)->keep_contents = true;
+	    }
+	}
+    }
+
+  /* Adjusting the internal symbols will not work if something has
+     already retrieved the generic symbols.  It would be possible to
+     make this work by adjusting the generic symbols at the same time.
+     However, this case should not arise in normal usage.  */
+  if (obj_symbols (abfd) != NULL
+      || obj_raw_syments (abfd) != NULL)
+    {
+      ((*_bfd_error_handler)
+       ("%s: fatal: generic symbols retrieved before relaxing",
+	bfd_archive_filename (abfd)));
+      bfd_set_error (bfd_error_invalid_operation);
+      return false;
+    }
+
+  /* Adjust all the symbols.  */
+  sym_hash = obj_coff_sym_hashes (abfd);
+  symesz = bfd_coff_symesz (abfd);
+  esym = (bfd_byte *) obj_coff_external_syms (abfd);
+  esymend = esym + obj_raw_syment_count (abfd) * symesz;
+  while (esym < esymend)
+    {
+      struct internal_syment isym;
+
+      bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
+
+      if (isym.n_scnum == sec->target_index
+	  && (bfd_vma) isym.n_value > addr
+	  && (bfd_vma) isym.n_value < toaddr)
+	{
+	  isym.n_value -= count;
+
+	  bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym);
+
+	  if (*sym_hash != NULL)
+	    {
+	      BFD_ASSERT ((*sym_hash)->root.type == bfd_link_hash_defined
+			  || (*sym_hash)->root.type == bfd_link_hash_defweak);
+	      BFD_ASSERT ((*sym_hash)->root.u.def.value >= addr
+			  && (*sym_hash)->root.u.def.value < toaddr);
+	      (*sym_hash)->root.u.def.value -= count;
+	    }
+	}
+
+      esym += (isym.n_numaux + 1) * symesz;
+      sym_hash += isym.n_numaux + 1;
+    }
+
+  /* See if we can move the ALIGN reloc forward.  We have adjusted
+     r_vaddr for it already.  */
+  if (irelalign != NULL)
+    {
+      bfd_vma alignto, alignaddr;
+
+      alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_offset);
+      alignaddr = BFD_ALIGN (irelalign->r_vaddr - sec->vma,
+			     1 << irelalign->r_offset);
+      if (alignto != alignaddr)
+	{
+	  /* Tail recursion.  */
+	  return sh_relax_delete_bytes (abfd, sec, alignaddr,
+					(int) (alignto - alignaddr));
+	}
+    }
+
+  return true;
+}
+
+/* This is yet another version of the SH opcode table, used to rapidly
+   get information about a particular instruction.  */
+
+/* The opcode map is represented by an array of these structures.  The
+   array is indexed by the high order four bits in the instruction.  */
+
+struct sh_major_opcode
+{
+  /* A pointer to the instruction list.  This is an array which
+     contains all the instructions with this major opcode.  */
+  const struct sh_minor_opcode *minor_opcodes;
+  /* The number of elements in minor_opcodes.  */
+  unsigned short count;
+};
+
+/* This structure holds information for a set of SH opcodes.  The
+   instruction code is anded with the mask value, and the resulting
+   value is used to search the order opcode list.  */
+
+struct sh_minor_opcode
+{
+  /* The sorted opcode list.  */
+  const struct sh_opcode *opcodes;
+  /* The number of elements in opcodes.  */
+  unsigned short count;
+  /* The mask value to use when searching the opcode list.  */
+  unsigned short mask;
+};
+
+/* This structure holds information for an SH instruction.  An array
+   of these structures is sorted in order by opcode.  */
+
+struct sh_opcode
+{
+  /* The code for this instruction, after it has been anded with the
+     mask value in the sh_major_opcode structure.  */
+  unsigned short opcode;
+  /* Flags for this instruction.  */
+  unsigned long flags;
+};
+
+/* Flag which appear in the sh_opcode structure.  */
+
+/* This instruction loads a value from memory.  */
+#define LOAD (0x1)
+
+/* This instruction stores a value to memory.  */
+#define STORE (0x2)
+
+/* This instruction is a branch.  */
+#define BRANCH (0x4)
+
+/* This instruction has a delay slot.  */
+#define DELAY (0x8)
+
+/* This instruction uses the value in the register in the field at
+   mask 0x0f00 of the instruction.  */
+#define USES1 (0x10)
+#define USES1_REG(x) ((x & 0x0f00) >> 8)
+
+/* This instruction uses the value in the register in the field at
+   mask 0x00f0 of the instruction.  */
+#define USES2 (0x20)
+#define USES2_REG(x) ((x & 0x00f0) >> 4)
+
+/* This instruction uses the value in register 0.  */
+#define USESR0 (0x40)
+
+/* This instruction sets the value in the register in the field at
+   mask 0x0f00 of the instruction.  */
+#define SETS1 (0x80)
+#define SETS1_REG(x) ((x & 0x0f00) >> 8)
+
+/* This instruction sets the value in the register in the field at
+   mask 0x00f0 of the instruction.  */
+#define SETS2 (0x100)
+#define SETS2_REG(x) ((x & 0x00f0) >> 4)
+
+/* This instruction sets register 0.  */
+#define SETSR0 (0x200)
+
+/* This instruction sets a special register.  */
+#define SETSSP (0x400)
+
+/* This instruction uses a special register.  */
+#define USESSP (0x800)
+
+/* This instruction uses the floating point register in the field at
+   mask 0x0f00 of the instruction.  */
+#define USESF1 (0x1000)
+#define USESF1_REG(x) ((x & 0x0f00) >> 8)
+
+/* This instruction uses the floating point register in the field at
+   mask 0x00f0 of the instruction.  */
+#define USESF2 (0x2000)
+#define USESF2_REG(x) ((x & 0x00f0) >> 4)
+
+/* This instruction uses floating point register 0.  */
+#define USESF0 (0x4000)
+
+/* This instruction sets the floating point register in the field at
+   mask 0x0f00 of the instruction.  */
+#define SETSF1 (0x8000)
+#define SETSF1_REG(x) ((x & 0x0f00) >> 8)
+
+#define USESAS (0x10000)
+#define USESAS_REG(x) (((((x) >> 8) - 2) & 3) + 2)
+#define USESR8 (0x20000)
+#define SETSAS (0x40000)
+#define SETSAS_REG(x) USESAS_REG (x)
+
+#ifndef COFF_IMAGE_WITH_PE
+static boolean sh_insn_uses_reg
+  PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
+static boolean sh_insn_sets_reg
+  PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
+static boolean sh_insn_uses_or_sets_reg
+  PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
+static boolean sh_insn_uses_freg
+  PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
+static boolean sh_insn_sets_freg
+  PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
+static boolean sh_insn_uses_or_sets_freg
+  PARAMS ((unsigned int, const struct sh_opcode *, unsigned int));
+static boolean sh_insns_conflict
+  PARAMS ((unsigned int, const struct sh_opcode *, unsigned int,
+	   const struct sh_opcode *));
+static boolean sh_load_use
+  PARAMS ((unsigned int, const struct sh_opcode *, unsigned int,
+	   const struct sh_opcode *));
+#endif
+/* The opcode maps.  */
+
+#define MAP(a) a, sizeof a / sizeof a[0]
+
+static const struct sh_opcode sh_opcode00[] =
+{
+  { 0x0008, SETSSP },			/* clrt */
+  { 0x0009, 0 },			/* nop */
+  { 0x000b, BRANCH | DELAY | USESSP },	/* rts */
+  { 0x0018, SETSSP },			/* sett */
+  { 0x0019, SETSSP },			/* div0u */
+  { 0x001b, 0 },			/* sleep */
+  { 0x0028, SETSSP },			/* clrmac */
+  { 0x002b, BRANCH | DELAY | SETSSP },	/* rte */
+  { 0x0038, USESSP | SETSSP },		/* ldtlb */
+  { 0x0048, SETSSP },			/* clrs */
+  { 0x0058, SETSSP }			/* sets */
+};
+
+static const struct sh_opcode sh_opcode01[] =
+{
+  { 0x0003, BRANCH | DELAY | USES1 | SETSSP },	/* bsrf rn */
+  { 0x000a, SETS1 | USESSP },			/* sts mach,rn */
+  { 0x001a, SETS1 | USESSP },			/* sts macl,rn */
+  { 0x0023, BRANCH | DELAY | USES1 },		/* braf rn */
+  { 0x0029, SETS1 | USESSP },			/* movt rn */
+  { 0x002a, SETS1 | USESSP },			/* sts pr,rn */
+  { 0x005a, SETS1 | USESSP },			/* sts fpul,rn */
+  { 0x006a, SETS1 | USESSP },			/* sts fpscr,rn / sts dsr,rn */
+  { 0x0083, LOAD | USES1 },			/* pref @rn */
+  { 0x007a, SETS1 | USESSP },			/* sts a0,rn */
+  { 0x008a, SETS1 | USESSP },			/* sts x0,rn */
+  { 0x009a, SETS1 | USESSP },			/* sts x1,rn */
+  { 0x00aa, SETS1 | USESSP },			/* sts y0,rn */
+  { 0x00ba, SETS1 | USESSP }			/* sts y1,rn */
+};
+
+/* These sixteen instructions can be handled with one table entry below.  */
+#if 0
+  { 0x0002, SETS1 | USESSP },			/* stc sr,rn */
+  { 0x0012, SETS1 | USESSP },			/* stc gbr,rn */
+  { 0x0022, SETS1 | USESSP },			/* stc vbr,rn */
+  { 0x0032, SETS1 | USESSP },			/* stc ssr,rn */
+  { 0x0042, SETS1 | USESSP },			/* stc spc,rn */
+  { 0x0052, SETS1 | USESSP },			/* stc mod,rn */
+  { 0x0062, SETS1 | USESSP },			/* stc rs,rn */
+  { 0x0072, SETS1 | USESSP },			/* stc re,rn */
+  { 0x0082, SETS1 | USESSP },			/* stc r0_bank,rn */
+  { 0x0092, SETS1 | USESSP },			/* stc r1_bank,rn */
+  { 0x00a2, SETS1 | USESSP },			/* stc r2_bank,rn */
+  { 0x00b2, SETS1 | USESSP },			/* stc r3_bank,rn */
+  { 0x00c2, SETS1 | USESSP },			/* stc r4_bank,rn */
+  { 0x00d2, SETS1 | USESSP },			/* stc r5_bank,rn */
+  { 0x00e2, SETS1 | USESSP },			/* stc r6_bank,rn */
+  { 0x00f2, SETS1 | USESSP }			/* stc r7_bank,rn */
+#endif
+
+static const struct sh_opcode sh_opcode02[] =
+{
+  { 0x0002, SETS1 | USESSP },			/* stc <special_reg>,rn */
+  { 0x0004, STORE | USES1 | USES2 | USESR0 },	/* mov.b rm,@(r0,rn) */
+  { 0x0005, STORE | USES1 | USES2 | USESR0 },	/* mov.w rm,@(r0,rn) */
+  { 0x0006, STORE | USES1 | USES2 | USESR0 },	/* mov.l rm,@(r0,rn) */
+  { 0x0007, SETSSP | USES1 | USES2 },		/* mul.l rm,rn */
+  { 0x000c, LOAD | SETS1 | USES2 | USESR0 },	/* mov.b @(r0,rm),rn */
+  { 0x000d, LOAD | SETS1 | USES2 | USESR0 },	/* mov.w @(r0,rm),rn */
+  { 0x000e, LOAD | SETS1 | USES2 | USESR0 },	/* mov.l @(r0,rm),rn */
+  { 0x000f, LOAD|SETS1|SETS2|SETSSP|USES1|USES2|USESSP }, /* mac.l @rm+,@rn+ */
+};
+
+static const struct sh_minor_opcode sh_opcode0[] =
+{
+  { MAP (sh_opcode00), 0xffff },
+  { MAP (sh_opcode01), 0xf0ff },
+  { MAP (sh_opcode02), 0xf00f }
+};
+
+static const struct sh_opcode sh_opcode10[] =
+{
+  { 0x1000, STORE | USES1 | USES2 }	/* mov.l rm,@(disp,rn) */
+};
+
+static const struct sh_minor_opcode sh_opcode1[] =
+{
+  { MAP (sh_opcode10), 0xf000 }
+};
+
+static const struct sh_opcode sh_opcode20[] =
+{
+  { 0x2000, STORE | USES1 | USES2 },		/* mov.b rm,@rn */
+  { 0x2001, STORE | USES1 | USES2 },		/* mov.w rm,@rn */
+  { 0x2002, STORE | USES1 | USES2 },		/* mov.l rm,@rn */
+  { 0x2004, STORE | SETS1 | USES1 | USES2 },	/* mov.b rm,@-rn */
+  { 0x2005, STORE | SETS1 | USES1 | USES2 },	/* mov.w rm,@-rn */
+  { 0x2006, STORE | SETS1 | USES1 | USES2 },	/* mov.l rm,@-rn */
+  { 0x2007, SETSSP | USES1 | USES2 | USESSP },	/* div0s */
+  { 0x2008, SETSSP | USES1 | USES2 },		/* tst rm,rn */
+  { 0x2009, SETS1 | USES1 | USES2 },		/* and rm,rn */
+  { 0x200a, SETS1 | USES1 | USES2 },		/* xor rm,rn */
+  { 0x200b, SETS1 | USES1 | USES2 },		/* or rm,rn */
+  { 0x200c, SETSSP | USES1 | USES2 },		/* cmp/str rm,rn */
+  { 0x200d, SETS1 | USES1 | USES2 },		/* xtrct rm,rn */
+  { 0x200e, SETSSP | USES1 | USES2 },		/* mulu.w rm,rn */
+  { 0x200f, SETSSP | USES1 | USES2 }		/* muls.w rm,rn */
+};
+
+static const struct sh_minor_opcode sh_opcode2[] =
+{
+  { MAP (sh_opcode20), 0xf00f }
+};
+
+static const struct sh_opcode sh_opcode30[] =
+{
+  { 0x3000, SETSSP | USES1 | USES2 },		/* cmp/eq rm,rn */
+  { 0x3002, SETSSP | USES1 | USES2 },		/* cmp/hs rm,rn */
+  { 0x3003, SETSSP | USES1 | USES2 },		/* cmp/ge rm,rn */
+  { 0x3004, SETSSP | USESSP | USES1 | USES2 },	/* div1 rm,rn */
+  { 0x3005, SETSSP | USES1 | USES2 },		/* dmulu.l rm,rn */
+  { 0x3006, SETSSP | USES1 | USES2 },		/* cmp/hi rm,rn */
+  { 0x3007, SETSSP | USES1 | USES2 },		/* cmp/gt rm,rn */
+  { 0x3008, SETS1 | USES1 | USES2 },		/* sub rm,rn */
+  { 0x300a, SETS1 | SETSSP | USES1 | USES2 | USESSP }, /* subc rm,rn */
+  { 0x300b, SETS1 | SETSSP | USES1 | USES2 },	/* subv rm,rn */
+  { 0x300c, SETS1 | USES1 | USES2 },		/* add rm,rn */
+  { 0x300d, SETSSP | USES1 | USES2 },		/* dmuls.l rm,rn */
+  { 0x300e, SETS1 | SETSSP | USES1 | USES2 | USESSP }, /* addc rm,rn */
+  { 0x300f, SETS1 | SETSSP | USES1 | USES2 }	/* addv rm,rn */
+};
+
+static const struct sh_minor_opcode sh_opcode3[] =
+{
+  { MAP (sh_opcode30), 0xf00f }
+};
+
+static const struct sh_opcode sh_opcode40[] =
+{
+  { 0x4000, SETS1 | SETSSP | USES1 },		/* shll rn */
+  { 0x4001, SETS1 | SETSSP | USES1 },		/* shlr rn */
+  { 0x4002, STORE | SETS1 | USES1 | USESSP },	/* sts.l mach,@-rn */
+  { 0x4004, SETS1 | SETSSP | USES1 },		/* rotl rn */
+  { 0x4005, SETS1 | SETSSP | USES1 },		/* rotr rn */
+  { 0x4006, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,mach */
+  { 0x4008, SETS1 | USES1 },			/* shll2 rn */
+  { 0x4009, SETS1 | USES1 },			/* shlr2 rn */
+  { 0x400a, SETSSP | USES1 },			/* lds rm,mach */
+  { 0x400b, BRANCH | DELAY | USES1 },		/* jsr @rn */
+  { 0x4010, SETS1 | SETSSP | USES1 },		/* dt rn */
+  { 0x4011, SETSSP | USES1 },			/* cmp/pz rn */
+  { 0x4012, STORE | SETS1 | USES1 | USESSP },	/* sts.l macl,@-rn */
+  { 0x4014, SETSSP | USES1 },			/* setrc rm */
+  { 0x4015, SETSSP | USES1 },			/* cmp/pl rn */
+  { 0x4016, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,macl */
+  { 0x4018, SETS1 | USES1 },			/* shll8 rn */
+  { 0x4019, SETS1 | USES1 },			/* shlr8 rn */
+  { 0x401a, SETSSP | USES1 },			/* lds rm,macl */
+  { 0x401b, LOAD | SETSSP | USES1 },		/* tas.b @rn */
+  { 0x4020, SETS1 | SETSSP | USES1 },		/* shal rn */
+  { 0x4021, SETS1 | SETSSP | USES1 },		/* shar rn */
+  { 0x4022, STORE | SETS1 | USES1 | USESSP },	/* sts.l pr,@-rn */
+  { 0x4024, SETS1 | SETSSP | USES1 | USESSP },	/* rotcl rn */
+  { 0x4025, SETS1 | SETSSP | USES1 | USESSP },	/* rotcr rn */
+  { 0x4026, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,pr */
+  { 0x4028, SETS1 | USES1 },			/* shll16 rn */
+  { 0x4029, SETS1 | USES1 },			/* shlr16 rn */
+  { 0x402a, SETSSP | USES1 },			/* lds rm,pr */
+  { 0x402b, BRANCH | DELAY | USES1 },		/* jmp @rn */
+  { 0x4052, STORE | SETS1 | USES1 | USESSP },	/* sts.l fpul,@-rn */
+  { 0x4056, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,fpul */
+  { 0x405a, SETSSP | USES1 },			/* lds.l rm,fpul */
+  { 0x4062, STORE | SETS1 | USES1 | USESSP },	/* sts.l fpscr / dsr,@-rn */
+  { 0x4066, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,fpscr / dsr */
+  { 0x406a, SETSSP | USES1 },			/* lds rm,fpscr / lds rm,dsr */
+  { 0x4072, STORE | SETS1 | USES1 | USESSP },	/* sts.l a0,@-rn */
+  { 0x4076, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,a0 */
+  { 0x407a, SETSSP | USES1 },			/* lds.l rm,a0 */
+  { 0x4082, STORE | SETS1 | USES1 | USESSP },	/* sts.l x0,@-rn */
+  { 0x4086, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,x0 */
+  { 0x408a, SETSSP | USES1 },			/* lds.l rm,x0 */
+  { 0x4092, STORE | SETS1 | USES1 | USESSP },	/* sts.l x1,@-rn */
+  { 0x4096, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,x1 */
+  { 0x409a, SETSSP | USES1 },			/* lds.l rm,x1 */
+  { 0x40a2, STORE | SETS1 | USES1 | USESSP },	/* sts.l y0,@-rn */
+  { 0x40a6, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,y0 */
+  { 0x40aa, SETSSP | USES1 },			/* lds.l rm,y0 */
+  { 0x40b2, STORE | SETS1 | USES1 | USESSP },	/* sts.l y1,@-rn */
+  { 0x40b6, LOAD | SETS1 | SETSSP | USES1 },	/* lds.l @rm+,y1 */
+  { 0x40ba, SETSSP | USES1 }			/* lds.l rm,y1 */
+#if 0 /* These groups sixteen insns can be
+         handled with one table entry each below.  */
+  { 0x4003, STORE | SETS1 | USES1 | USESSP },	/* stc.l sr,@-rn */
+  { 0x4013, STORE | SETS1 | USES1 | USESSP },	/* stc.l gbr,@-rn */
+  { 0x4023, STORE | SETS1 | USES1 | USESSP },	/* stc.l vbr,@-rn */
+  { 0x4033, STORE | SETS1 | USES1 | USESSP },	/* stc.l ssr,@-rn */
+  { 0x4043, STORE | SETS1 | USES1 | USESSP },	/* stc.l spc,@-rn */
+  { 0x4053, STORE | SETS1 | USES1 | USESSP },	/* stc.l mod,@-rn */
+  { 0x4063, STORE | SETS1 | USES1 | USESSP },	/* stc.l rs,@-rn */
+  { 0x4073, STORE | SETS1 | USES1 | USESSP },	/* stc.l re,@-rn */
+  { 0x4083, STORE | SETS1 | USES1 | USESSP },	/* stc.l r0_bank,@-rn */
+  ..
+  { 0x40f3, STORE | SETS1 | USES1 | USESSP },	/* stc.l r7_bank,@-rn */
+
+  { 0x4007, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,sr */
+  { 0x4017, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,gbr */
+  { 0x4027, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,vbr */
+  { 0x4037, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,ssr */
+  { 0x4047, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,spc */
+  { 0x4057, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,mod */
+  { 0x4067, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,rs */
+  { 0x4077, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,re */
+  { 0x4087, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,r0_bank */
+  ..
+  { 0x40f7, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,r7_bank */
+
+  { 0x400e, SETSSP | USES1 },			/* ldc rm,sr */
+  { 0x401e, SETSSP | USES1 },			/* ldc rm,gbr */
+  { 0x402e, SETSSP | USES1 },			/* ldc rm,vbr */
+  { 0x403e, SETSSP | USES1 },			/* ldc rm,ssr */
+  { 0x404e, SETSSP | USES1 },			/* ldc rm,spc */
+  { 0x405e, SETSSP | USES1 },			/* ldc rm,mod */
+  { 0x406e, SETSSP | USES1 },			/* ldc rm,rs */
+  { 0x407e, SETSSP | USES1 }			/* ldc rm,re */
+  { 0x408e, SETSSP | USES1 }			/* ldc rm,r0_bank */
+  ..
+  { 0x40fe, SETSSP | USES1 }			/* ldc rm,r7_bank */
+#endif
+};
+
+static const struct sh_opcode sh_opcode41[] =
+{
+  { 0x4003, STORE | SETS1 | USES1 | USESSP },	/* stc.l <special_reg>,@-rn */
+  { 0x4007, LOAD | SETS1 | SETSSP | USES1 },	/* ldc.l @rm+,<special_reg> */
+  { 0x400c, SETS1 | USES1 | USES2 },		/* shad rm,rn */
+  { 0x400d, SETS1 | USES1 | USES2 },		/* shld rm,rn */
+  { 0x400e, SETSSP | USES1 },			/* ldc rm,<special_reg> */
+  { 0x400f, LOAD|SETS1|SETS2|SETSSP|USES1|USES2|USESSP }, /* mac.w @rm+,@rn+ */
+};
+
+static const struct sh_minor_opcode sh_opcode4[] =
+{
+  { MAP (sh_opcode40), 0xf0ff },
+  { MAP (sh_opcode41), 0xf00f }
+};
+
+static const struct sh_opcode sh_opcode50[] =
+{
+  { 0x5000, LOAD | SETS1 | USES2 }	/* mov.l @(disp,rm),rn */
+};
+
+static const struct sh_minor_opcode sh_opcode5[] =
+{
+  { MAP (sh_opcode50), 0xf000 }
+};
+
+static const struct sh_opcode sh_opcode60[] =
+{
+  { 0x6000, LOAD | SETS1 | USES2 },		/* mov.b @rm,rn */
+  { 0x6001, LOAD | SETS1 | USES2 },		/* mov.w @rm,rn */
+  { 0x6002, LOAD | SETS1 | USES2 },		/* mov.l @rm,rn */
+  { 0x6003, SETS1 | USES2 },			/* mov rm,rn */
+  { 0x6004, LOAD | SETS1 | SETS2 | USES2 },	/* mov.b @rm+,rn */
+  { 0x6005, LOAD | SETS1 | SETS2 | USES2 },	/* mov.w @rm+,rn */
+  { 0x6006, LOAD | SETS1 | SETS2 | USES2 },	/* mov.l @rm+,rn */
+  { 0x6007, SETS1 | USES2 },			/* not rm,rn */
+  { 0x6008, SETS1 | USES2 },			/* swap.b rm,rn */
+  { 0x6009, SETS1 | USES2 },			/* swap.w rm,rn */
+  { 0x600a, SETS1 | SETSSP | USES2 | USESSP },	/* negc rm,rn */
+  { 0x600b, SETS1 | USES2 },			/* neg rm,rn */
+  { 0x600c, SETS1 | USES2 },			/* extu.b rm,rn */
+  { 0x600d, SETS1 | USES2 },			/* extu.w rm,rn */
+  { 0x600e, SETS1 | USES2 },			/* exts.b rm,rn */
+  { 0x600f, SETS1 | USES2 }			/* exts.w rm,rn */
+};
+
+static const struct sh_minor_opcode sh_opcode6[] =
+{
+  { MAP (sh_opcode60), 0xf00f }
+};
+
+static const struct sh_opcode sh_opcode70[] =
+{
+  { 0x7000, SETS1 | USES1 }		/* add #imm,rn */
+};
+
+static const struct sh_minor_opcode sh_opcode7[] =
+{
+  { MAP (sh_opcode70), 0xf000 }
+};
+
+static const struct sh_opcode sh_opcode80[] =
+{
+  { 0x8000, STORE | USES2 | USESR0 },	/* mov.b r0,@(disp,rn) */
+  { 0x8100, STORE | USES2 | USESR0 },	/* mov.w r0,@(disp,rn) */
+  { 0x8200, SETSSP },			/* setrc #imm */
+  { 0x8400, LOAD | SETSR0 | USES2 },	/* mov.b @(disp,rm),r0 */
+  { 0x8500, LOAD | SETSR0 | USES2 },	/* mov.w @(disp,rn),r0 */
+  { 0x8800, SETSSP | USESR0 },		/* cmp/eq #imm,r0 */
+  { 0x8900, BRANCH | USESSP },		/* bt label */
+  { 0x8b00, BRANCH | USESSP },		/* bf label */
+  { 0x8c00, SETSSP },			/* ldrs @(disp,pc) */
+  { 0x8d00, BRANCH | DELAY | USESSP },	/* bt/s label */
+  { 0x8e00, SETSSP },			/* ldre @(disp,pc) */
+  { 0x8f00, BRANCH | DELAY | USESSP }	/* bf/s label */
+};
+
+static const struct sh_minor_opcode sh_opcode8[] =
+{
+  { MAP (sh_opcode80), 0xff00 }
+};
+
+static const struct sh_opcode sh_opcode90[] =
+{
+  { 0x9000, LOAD | SETS1 }	/* mov.w @(disp,pc),rn */
+};
+
+static const struct sh_minor_opcode sh_opcode9[] =
+{
+  { MAP (sh_opcode90), 0xf000 }
+};
+
+static const struct sh_opcode sh_opcodea0[] =
+{
+  { 0xa000, BRANCH | DELAY }	/* bra label */
+};
+
+static const struct sh_minor_opcode sh_opcodea[] =
+{
+  { MAP (sh_opcodea0), 0xf000 }
+};
+
+static const struct sh_opcode sh_opcodeb0[] =
+{
+  { 0xb000, BRANCH | DELAY }	/* bsr label */
+};
+
+static const struct sh_minor_opcode sh_opcodeb[] =
+{
+  { MAP (sh_opcodeb0), 0xf000 }
+};
+
+static const struct sh_opcode sh_opcodec0[] =
+{
+  { 0xc000, STORE | USESR0 | USESSP },		/* mov.b r0,@(disp,gbr) */
+  { 0xc100, STORE | USESR0 | USESSP },		/* mov.w r0,@(disp,gbr) */
+  { 0xc200, STORE | USESR0 | USESSP },		/* mov.l r0,@(disp,gbr) */
+  { 0xc300, BRANCH | USESSP },			/* trapa #imm */
+  { 0xc400, LOAD | SETSR0 | USESSP },		/* mov.b @(disp,gbr),r0 */
+  { 0xc500, LOAD | SETSR0 | USESSP },		/* mov.w @(disp,gbr),r0 */
+  { 0xc600, LOAD | SETSR0 | USESSP },		/* mov.l @(disp,gbr),r0 */
+  { 0xc700, SETSR0 },				/* mova @(disp,pc),r0 */
+  { 0xc800, SETSSP | USESR0 },			/* tst #imm,r0 */
+  { 0xc900, SETSR0 | USESR0 },			/* and #imm,r0 */
+  { 0xca00, SETSR0 | USESR0 },			/* xor #imm,r0 */
+  { 0xcb00, SETSR0 | USESR0 },			/* or #imm,r0 */
+  { 0xcc00, LOAD | SETSSP | USESR0 | USESSP },	/* tst.b #imm,@(r0,gbr) */
+  { 0xcd00, LOAD | STORE | USESR0 | USESSP },	/* and.b #imm,@(r0,gbr) */
+  { 0xce00, LOAD | STORE | USESR0 | USESSP },	/* xor.b #imm,@(r0,gbr) */
+  { 0xcf00, LOAD | STORE | USESR0 | USESSP }	/* or.b #imm,@(r0,gbr) */
+};
+
+static const struct sh_minor_opcode sh_opcodec[] =
+{
+  { MAP (sh_opcodec0), 0xff00 }
+};
+
+static const struct sh_opcode sh_opcoded0[] =
+{
+  { 0xd000, LOAD | SETS1 }		/* mov.l @(disp,pc),rn */
+};
+
+static const struct sh_minor_opcode sh_opcoded[] =
+{
+  { MAP (sh_opcoded0), 0xf000 }
+};
+
+static const struct sh_opcode sh_opcodee0[] =
+{
+  { 0xe000, SETS1 }		/* mov #imm,rn */
+};
+
+static const struct sh_minor_opcode sh_opcodee[] =
+{
+  { MAP (sh_opcodee0), 0xf000 }
+};
+
+static const struct sh_opcode sh_opcodef0[] =
+{
+  { 0xf000, SETSF1 | USESF1 | USESF2 },		/* fadd fm,fn */
+  { 0xf001, SETSF1 | USESF1 | USESF2 },		/* fsub fm,fn */
+  { 0xf002, SETSF1 | USESF1 | USESF2 },		/* fmul fm,fn */
+  { 0xf003, SETSF1 | USESF1 | USESF2 },		/* fdiv fm,fn */
+  { 0xf004, SETSSP | USESF1 | USESF2 },		/* fcmp/eq fm,fn */
+  { 0xf005, SETSSP | USESF1 | USESF2 },		/* fcmp/gt fm,fn */
+  { 0xf006, LOAD | SETSF1 | USES2 | USESR0 },	/* fmov.s @(r0,rm),fn */
+  { 0xf007, STORE | USES1 | USESF2 | USESR0 },	/* fmov.s fm,@(r0,rn) */
+  { 0xf008, LOAD | SETSF1 | USES2 },		/* fmov.s @rm,fn */
+  { 0xf009, LOAD | SETS2 | SETSF1 | USES2 },	/* fmov.s @rm+,fn */
+  { 0xf00a, STORE | USES1 | USESF2 },		/* fmov.s fm,@rn */
+  { 0xf00b, STORE | SETS1 | USES1 | USESF2 },	/* fmov.s fm,@-rn */
+  { 0xf00c, SETSF1 | USESF2 },			/* fmov fm,fn */
+  { 0xf00e, SETSF1 | USESF1 | USESF2 | USESF0 }	/* fmac f0,fm,fn */
+};
+
+static const struct sh_opcode sh_opcodef1[] =
+{
+  { 0xf00d, SETSF1 | USESSP },	/* fsts fpul,fn */
+  { 0xf01d, SETSSP | USESF1 },	/* flds fn,fpul */
+  { 0xf02d, SETSF1 | USESSP },	/* float fpul,fn */
+  { 0xf03d, SETSSP | USESF1 },	/* ftrc fn,fpul */
+  { 0xf04d, SETSF1 | USESF1 },	/* fneg fn */
+  { 0xf05d, SETSF1 | USESF1 },	/* fabs fn */
+  { 0xf06d, SETSF1 | USESF1 },	/* fsqrt fn */
+  { 0xf07d, SETSSP | USESF1 },	/* ftst/nan fn */
+  { 0xf08d, SETSF1 },		/* fldi0 fn */
+  { 0xf09d, SETSF1 }		/* fldi1 fn */
+};
+
+static const struct sh_minor_opcode sh_opcodef[] =
+{
+  { MAP (sh_opcodef0), 0xf00f },
+  { MAP (sh_opcodef1), 0xf0ff }
+};
+
+#ifndef COFF_IMAGE_WITH_PE
+static struct sh_major_opcode sh_opcodes[] =
+{
+  { MAP (sh_opcode0) },
+  { MAP (sh_opcode1) },
+  { MAP (sh_opcode2) },
+  { MAP (sh_opcode3) },
+  { MAP (sh_opcode4) },
+  { MAP (sh_opcode5) },
+  { MAP (sh_opcode6) },
+  { MAP (sh_opcode7) },
+  { MAP (sh_opcode8) },
+  { MAP (sh_opcode9) },
+  { MAP (sh_opcodea) },
+  { MAP (sh_opcodeb) },
+  { MAP (sh_opcodec) },
+  { MAP (sh_opcoded) },
+  { MAP (sh_opcodee) },
+  { MAP (sh_opcodef) }
+};
+#endif
+
+/* The double data transfer / parallel processing insns are not
+   described here.  This will cause sh_align_load_span to leave them alone.  */
+
+static const struct sh_opcode sh_dsp_opcodef0[] =
+{
+  { 0xf400, USESAS | SETSAS | LOAD | SETSSP },	/* movs.x @-as,ds */
+  { 0xf401, USESAS | SETSAS | STORE | USESSP },	/* movs.x ds,@-as */
+  { 0xf404, USESAS | LOAD | SETSSP },		/* movs.x @as,ds */
+  { 0xf405, USESAS | STORE | USESSP },		/* movs.x ds,@as */
+  { 0xf408, USESAS | SETSAS | LOAD | SETSSP },	/* movs.x @as+,ds */
+  { 0xf409, USESAS | SETSAS | STORE | USESSP },	/* movs.x ds,@as+ */
+  { 0xf40c, USESAS | SETSAS | LOAD | SETSSP | USESR8 },	/* movs.x @as+r8,ds */
+  { 0xf40d, USESAS | SETSAS | STORE | USESSP | USESR8 }	/* movs.x ds,@as+r8 */
+};
+
+static const struct sh_minor_opcode sh_dsp_opcodef[] =
+{
+  { MAP (sh_dsp_opcodef0), 0xfc0d }
+};
+
+#ifndef COFF_IMAGE_WITH_PE
+/* Given an instruction, return a pointer to the corresponding
+   sh_opcode structure.  Return NULL if the instruction is not
+   recognized.  */
+
+static const struct sh_opcode *
+sh_insn_info (insn)
+     unsigned int insn;
+{
+  const struct sh_major_opcode *maj;
+  const struct sh_minor_opcode *min, *minend;
+
+  maj = &sh_opcodes[(insn & 0xf000) >> 12];
+  min = maj->minor_opcodes;
+  minend = min + maj->count;
+  for (; min < minend; min++)
+    {
+      unsigned int l;
+      const struct sh_opcode *op, *opend;
+
+      l = insn & min->mask;
+      op = min->opcodes;
+      opend = op + min->count;
+
+      /* Since the opcodes tables are sorted, we could use a binary
+         search here if the count were above some cutoff value.  */
+      for (; op < opend; op++)
+	if (op->opcode == l)
+	  return op;
+    }
+
+  return NULL;
+}
+
+/* See whether an instruction uses or sets a general purpose register */
+
+static boolean
+sh_insn_uses_or_sets_reg (insn, op, reg)
+     unsigned int insn;
+     const struct sh_opcode *op;
+     unsigned int reg;
+{
+  if (sh_insn_uses_reg (insn, op, reg))
+    return true;
+
+  return sh_insn_sets_reg (insn, op, reg);
+}
+
+/* See whether an instruction uses a general purpose register.  */
+
+static boolean
+sh_insn_uses_reg (insn, op, reg)
+     unsigned int insn;
+     const struct sh_opcode *op;
+     unsigned int reg;
+{
+  unsigned int f;
+
+  f = op->flags;
+
+  if ((f & USES1) != 0
+      && USES1_REG (insn) == reg)
+    return true;
+  if ((f & USES2) != 0
+      && USES2_REG (insn) == reg)
+    return true;
+  if ((f & USESR0) != 0
+      && reg == 0)
+    return true;
+  if ((f & USESAS) && reg == USESAS_REG (insn))
+    return true;
+  if ((f & USESR8) && reg == 8)
+    return true;
+
+  return false;
+}
+
+/* See whether an instruction sets a general purpose register.  */
+
+static boolean
+sh_insn_sets_reg (insn, op, reg)
+     unsigned int insn;
+     const struct sh_opcode *op;
+     unsigned int reg;
+{
+  unsigned int f;
+
+  f = op->flags;
+
+  if ((f & SETS1) != 0
+      && SETS1_REG (insn) == reg)
+    return true;
+  if ((f & SETS2) != 0
+      && SETS2_REG (insn) == reg)
+    return true;
+  if ((f & SETSR0) != 0
+      && reg == 0)
+    return true;
+  if ((f & SETSAS) && reg == SETSAS_REG (insn))
+    return true;
+
+  return false;
+}
+
+/* See whether an instruction uses or sets a floating point register */
+
+static boolean
+sh_insn_uses_or_sets_freg (insn, op, reg)
+     unsigned int insn;
+     const struct sh_opcode *op;
+     unsigned int reg;
+{
+  if (sh_insn_uses_freg (insn, op, reg))
+    return true;
+
+  return sh_insn_sets_freg (insn, op, reg);
+}
+
+/* See whether an instruction uses a floating point register.  */
+
+static boolean
+sh_insn_uses_freg (insn, op, freg)
+     unsigned int insn;
+     const struct sh_opcode *op;
+     unsigned int freg;
+{
+  unsigned int f;
+
+  f = op->flags;
+
+  /* We can't tell if this is a double-precision insn, so just play safe
+     and assume that it might be.  So not only have we test FREG against
+     itself, but also even FREG against FREG+1 - if the using insn uses
+     just the low part of a double precision value - but also an odd
+     FREG against FREG-1 -  if the setting insn sets just the low part
+     of a double precision value.
+     So what this all boils down to is that we have to ignore the lowest
+     bit of the register number.  */
+
+  if ((f & USESF1) != 0
+      && (USESF1_REG (insn) & 0xe) == (freg & 0xe))
+    return true;
+  if ((f & USESF2) != 0
+      && (USESF2_REG (insn) & 0xe) == (freg & 0xe))
+    return true;
+  if ((f & USESF0) != 0
+      && freg == 0)
+    return true;
+
+  return false;
+}
+
+/* See whether an instruction sets a floating point register.  */
+
+static boolean
+sh_insn_sets_freg (insn, op, freg)
+     unsigned int insn;
+     const struct sh_opcode *op;
+     unsigned int freg;
+{
+  unsigned int f;
+
+  f = op->flags;
+
+  /* We can't tell if this is a double-precision insn, so just play safe
+     and assume that it might be.  So not only have we test FREG against
+     itself, but also even FREG against FREG+1 - if the using insn uses
+     just the low part of a double precision value - but also an odd
+     FREG against FREG-1 -  if the setting insn sets just the low part
+     of a double precision value.
+     So what this all boils down to is that we have to ignore the lowest
+     bit of the register number.  */
+
+  if ((f & SETSF1) != 0
+      && (SETSF1_REG (insn) & 0xe) == (freg & 0xe))
+    return true;
+
+  return false;
+}
+
+/* See whether instructions I1 and I2 conflict, assuming I1 comes
+   before I2.  OP1 and OP2 are the corresponding sh_opcode structures.
+   This should return true if there is a conflict, or false if the
+   instructions can be swapped safely.  */
+
+static boolean
+sh_insns_conflict (i1, op1, i2, op2)
+     unsigned int i1;
+     const struct sh_opcode *op1;
+     unsigned int i2;
+     const struct sh_opcode *op2;
+{
+  unsigned int f1, f2;
+
+  f1 = op1->flags;
+  f2 = op2->flags;
+
+  /* Load of fpscr conflicts with floating point operations.
+     FIXME: shouldn't test raw opcodes here.  */
+  if (((i1 & 0xf0ff) == 0x4066 && (i2 & 0xf000) == 0xf000)
+      || ((i2 & 0xf0ff) == 0x4066 && (i1 & 0xf000) == 0xf000))
+    return true;
+
+  if ((f1 & (BRANCH | DELAY)) != 0
+      || (f2 & (BRANCH | DELAY)) != 0)
+    return true;
+
+  if (((f1 | f2) & SETSSP)
+      && (f1 & (SETSSP | USESSP))
+      && (f2 & (SETSSP | USESSP)))
+    return true;
+
+  if ((f1 & SETS1) != 0
+      && sh_insn_uses_or_sets_reg (i2, op2, SETS1_REG (i1)))
+    return true;
+  if ((f1 & SETS2) != 0
+      && sh_insn_uses_or_sets_reg (i2, op2, SETS2_REG (i1)))
+    return true;
+  if ((f1 & SETSR0) != 0
+      && sh_insn_uses_or_sets_reg (i2, op2, 0))
+    return true;
+  if ((f1 & SETSAS)
+      && sh_insn_uses_or_sets_reg (i2, op2, SETSAS_REG (i1)))
+    return true;
+  if ((f1 & SETSF1) != 0
+      && sh_insn_uses_or_sets_freg (i2, op2, SETSF1_REG (i1)))
+    return true;
+
+  if ((f2 & SETS1) != 0
+      && sh_insn_uses_or_sets_reg (i1, op1, SETS1_REG (i2)))
+    return true;
+  if ((f2 & SETS2) != 0
+      && sh_insn_uses_or_sets_reg (i1, op1, SETS2_REG (i2)))
+    return true;
+  if ((f2 & SETSR0) != 0
+      && sh_insn_uses_or_sets_reg (i1, op1, 0))
+    return true;
+  if ((f2 & SETSAS)
+      && sh_insn_uses_or_sets_reg (i1, op1, SETSAS_REG (i2)))
+    return true;
+  if ((f2 & SETSF1) != 0
+      && sh_insn_uses_or_sets_freg (i1, op1, SETSF1_REG (i2)))
+    return true;
+
+  /* The instructions do not conflict.  */
+  return false;
+}
+
+/* I1 is a load instruction, and I2 is some other instruction.  Return
+   true if I1 loads a register which I2 uses.  */
+
+static boolean
+sh_load_use (i1, op1, i2, op2)
+     unsigned int i1;
+     const struct sh_opcode *op1;
+     unsigned int i2;
+     const struct sh_opcode *op2;
+{
+  unsigned int f1;
+
+  f1 = op1->flags;
+
+  if ((f1 & LOAD) == 0)
+    return false;
+
+  /* If both SETS1 and SETSSP are set, that means a load to a special
+     register using postincrement addressing mode, which we don't care
+     about here.  */
+  if ((f1 & SETS1) != 0
+      && (f1 & SETSSP) == 0
+      && sh_insn_uses_reg (i2, op2, (i1 & 0x0f00) >> 8))
+    return true;
+
+  if ((f1 & SETSR0) != 0
+      && sh_insn_uses_reg (i2, op2, 0))
+    return true;
+
+  if ((f1 & SETSF1) != 0
+      && sh_insn_uses_freg (i2, op2, (i1 & 0x0f00) >> 8))
+    return true;
+
+  return false;
+}
+
+/* Try to align loads and stores within a span of memory.  This is
+   called by both the ELF and the COFF sh targets.  ABFD and SEC are
+   the BFD and section we are examining.  CONTENTS is the contents of
+   the section.  SWAP is the routine to call to swap two instructions.
+   RELOCS is a pointer to the internal relocation information, to be
+   passed to SWAP.  PLABEL is a pointer to the current label in a
+   sorted list of labels; LABEL_END is the end of the list.  START and
+   STOP are the range of memory to examine.  If a swap is made,
+   *PSWAPPED is set to true.  */
+
+#ifdef COFF_WITH_PE
+static
+#endif
+boolean
+_bfd_sh_align_load_span (abfd, sec, contents, swap, relocs,
+			 plabel, label_end, start, stop, pswapped)
+     bfd *abfd;
+     asection *sec;
+     bfd_byte *contents;
+     boolean (*swap) PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
+     PTR relocs;
+     bfd_vma **plabel;
+     bfd_vma *label_end;
+     bfd_vma start;
+     bfd_vma stop;
+     boolean *pswapped;
+{
+  int dsp = (abfd->arch_info->mach == bfd_mach_sh_dsp
+	     || abfd->arch_info->mach == bfd_mach_sh3_dsp);
+  bfd_vma i;
+
+  /* The SH4 has a Harvard architecture, hence aligning loads is not
+     desirable.  In fact, it is counter-productive, since it interferes
+     with the schedules generated by the compiler.  */
+  if (abfd->arch_info->mach == bfd_mach_sh4)
+    return true;
+
+  /* If we are linking sh[3]-dsp code, swap the FPU instructions for DSP
+     instructions.  */
+  if (dsp)
+    {
+      sh_opcodes[0xf].minor_opcodes = sh_dsp_opcodef;
+      sh_opcodes[0xf].count = sizeof sh_dsp_opcodef / sizeof sh_dsp_opcodef;
+    }
+
+  /* Instructions should be aligned on 2 byte boundaries.  */
+  if ((start & 1) == 1)
+    ++start;
+
+  /* Now look through the unaligned addresses.  */
+  i = start;
+  if ((i & 2) == 0)
+    i += 2;
+  for (; i < stop; i += 4)
+    {
+      unsigned int insn;
+      const struct sh_opcode *op;
+      unsigned int prev_insn = 0;
+      const struct sh_opcode *prev_op = NULL;
+
+      insn = bfd_get_16 (abfd, contents + i);
+      op = sh_insn_info (insn);
+      if (op == NULL
+	  || (op->flags & (LOAD | STORE)) == 0)
+	continue;
+
+      /* This is a load or store which is not on a four byte boundary.  */
+
+      while (*plabel < label_end && **plabel < i)
+	++*plabel;
+
+      if (i > start)
+	{
+	  prev_insn = bfd_get_16 (abfd, contents + i - 2);
+	  /* If INSN is the field b of a parallel processing insn, it is not
+	     a load / store after all.  Note that the test here might mistake
+	     the field_b of a pcopy insn for the starting code of a parallel
+	     processing insn; this might miss a swapping opportunity, but at
+	     least we're on the safe side.  */
+	  if (dsp && (prev_insn & 0xfc00) == 0xf800)
+	    continue;
+
+	  /* Check if prev_insn is actually the field b of a parallel
+	     processing insn.  Again, this can give a spurious match
+	     after a pcopy.  */
+	  if (dsp && i - 2 > start)
+	    {
+	      unsigned pprev_insn = bfd_get_16 (abfd, contents + i - 4);
+
+	      if ((pprev_insn & 0xfc00) == 0xf800)
+		prev_op = NULL;
+	      else
+		prev_op = sh_insn_info (prev_insn);
+	    }
+	  else
+	    prev_op = sh_insn_info (prev_insn);
+
+	  /* If the load/store instruction is in a delay slot, we
+	     can't swap.  */
+	  if (prev_op == NULL
+	      || (prev_op->flags & DELAY) != 0)
+	    continue;
+	}
+      if (i > start
+	  && (*plabel >= label_end || **plabel != i)
+	  && prev_op != NULL
+	  && (prev_op->flags & (LOAD | STORE)) == 0
+	  && ! sh_insns_conflict (prev_insn, prev_op, insn, op))
+	{
+	  boolean ok;
+
+	  /* The load/store instruction does not have a label, and
+	     there is a previous instruction; PREV_INSN is not
+	     itself a load/store instruction, and PREV_INSN and
+	     INSN do not conflict.  */
+
+	  ok = true;
+
+	  if (i >= start + 4)
+	    {
+	      unsigned int prev2_insn;
+	      const struct sh_opcode *prev2_op;
+
+	      prev2_insn = bfd_get_16 (abfd, contents + i - 4);
+	      prev2_op = sh_insn_info (prev2_insn);
+
+	      /* If the instruction before PREV_INSN has a delay
+		 slot--that is, PREV_INSN is in a delay slot--we
+		 can not swap.  */
+	      if (prev2_op == NULL
+		  || (prev2_op->flags & DELAY) != 0)
+		ok = false;
+
+	      /* If the instruction before PREV_INSN is a load,
+		 and it sets a register which INSN uses, then
+		 putting INSN immediately after PREV_INSN will
+		 cause a pipeline bubble, so there is no point to
+		 making the swap.  */
+	      if (ok
+		  && (prev2_op->flags & LOAD) != 0
+		  && sh_load_use (prev2_insn, prev2_op, insn, op))
+		ok = false;
+	    }
+
+	  if (ok)
+	    {
+	      if (! (*swap) (abfd, sec, relocs, contents, i - 2))
+		return false;
+	      *pswapped = true;
+	      continue;
+	    }
+	}
+
+      while (*plabel < label_end && **plabel < i + 2)
+	++*plabel;
+
+      if (i + 2 < stop
+	  && (*plabel >= label_end || **plabel != i + 2))
+	{
+	  unsigned int next_insn;
+	  const struct sh_opcode *next_op;
+
+	  /* There is an instruction after the load/store
+	     instruction, and it does not have a label.  */
+	  next_insn = bfd_get_16 (abfd, contents + i + 2);
+	  next_op = sh_insn_info (next_insn);
+	  if (next_op != NULL
+	      && (next_op->flags & (LOAD | STORE)) == 0
+	      && ! sh_insns_conflict (insn, op, next_insn, next_op))
+	    {
+	      boolean ok;
+
+	      /* NEXT_INSN is not itself a load/store instruction,
+		 and it does not conflict with INSN.  */
+
+	      ok = true;
+
+	      /* If PREV_INSN is a load, and it sets a register
+		 which NEXT_INSN uses, then putting NEXT_INSN
+		 immediately after PREV_INSN will cause a pipeline
+		 bubble, so there is no reason to make this swap.  */
+	      if (prev_op != NULL
+		  && (prev_op->flags & LOAD) != 0
+		  && sh_load_use (prev_insn, prev_op, next_insn, next_op))
+		ok = false;
+
+	      /* If INSN is a load, and it sets a register which
+		 the insn after NEXT_INSN uses, then doing the
+		 swap will cause a pipeline bubble, so there is no
+		 reason to make the swap.  However, if the insn
+		 after NEXT_INSN is itself a load or store
+		 instruction, then it is misaligned, so
+		 optimistically hope that it will be swapped
+		 itself, and just live with the pipeline bubble if
+		 it isn't.  */
+	      if (ok
+		  && i + 4 < stop
+		  && (op->flags & LOAD) != 0)
+		{
+		  unsigned int next2_insn;
+		  const struct sh_opcode *next2_op;
+
+		  next2_insn = bfd_get_16 (abfd, contents + i + 4);
+		  next2_op = sh_insn_info (next2_insn);
+		  if ((next2_op->flags & (LOAD | STORE)) == 0
+		      && sh_load_use (insn, op, next2_insn, next2_op))
+		    ok = false;
+		}
+
+	      if (ok)
+		{
+		  if (! (*swap) (abfd, sec, relocs, contents, i))
+		    return false;
+		  *pswapped = true;
+		  continue;
+		}
+	    }
+	}
+    }
+
+  return true;
+}
+#endif /* not COFF_IMAGE_WITH_PE */
+
+/* Look for loads and stores which we can align to four byte
+   boundaries.  See the longer comment above sh_relax_section for why
+   this is desirable.  This sets *PSWAPPED if some instruction was
+   swapped.  */
+
+static boolean
+sh_align_loads (abfd, sec, internal_relocs, contents, pswapped)
+     bfd *abfd;
+     asection *sec;
+     struct internal_reloc *internal_relocs;
+     bfd_byte *contents;
+     boolean *pswapped;
+{
+  struct internal_reloc *irel, *irelend;
+  bfd_vma *labels = NULL;
+  bfd_vma *label, *label_end;
+  bfd_size_type amt;
+
+  *pswapped = false;
+
+  irelend = internal_relocs + sec->reloc_count;
+
+  /* Get all the addresses with labels on them.  */
+  amt = (bfd_size_type) sec->reloc_count * sizeof (bfd_vma);
+  labels = (bfd_vma *) bfd_malloc (amt);
+  if (labels == NULL)
+    goto error_return;
+  label_end = labels;
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      if (irel->r_type == R_SH_LABEL)
+	{
+	  *label_end = irel->r_vaddr - sec->vma;
+	  ++label_end;
+	}
+    }
+
+  /* Note that the assembler currently always outputs relocs in
+     address order.  If that ever changes, this code will need to sort
+     the label values and the relocs.  */
+
+  label = labels;
+
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      bfd_vma start, stop;
+
+      if (irel->r_type != R_SH_CODE)
+	continue;
+
+      start = irel->r_vaddr - sec->vma;
+
+      for (irel++; irel < irelend; irel++)
+	if (irel->r_type == R_SH_DATA)
+	  break;
+      if (irel < irelend)
+	stop = irel->r_vaddr - sec->vma;
+      else
+	stop = sec->_cooked_size;
+
+      if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_swap_insns,
+				     (PTR) internal_relocs, &label,
+				     label_end, start, stop, pswapped))
+	goto error_return;
+    }
+
+  free (labels);
+
+  return true;
+
+ error_return:
+  if (labels != NULL)
+    free (labels);
+  return false;
+}
+
+/* Swap two SH instructions.  */
+
+static boolean
+sh_swap_insns (abfd, sec, relocs, contents, addr)
+     bfd *abfd;
+     asection *sec;
+     PTR relocs;
+     bfd_byte *contents;
+     bfd_vma addr;
+{
+  struct internal_reloc *internal_relocs = (struct internal_reloc *) relocs;
+  unsigned short i1, i2;
+  struct internal_reloc *irel, *irelend;
+
+  /* Swap the instructions themselves.  */
+  i1 = bfd_get_16 (abfd, contents + addr);
+  i2 = bfd_get_16 (abfd, contents + addr + 2);
+  bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
+  bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
+
+  /* Adjust all reloc addresses.  */
+  irelend = internal_relocs + sec->reloc_count;
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      int type, add;
+
+      /* There are a few special types of relocs that we don't want to
+         adjust.  These relocs do not apply to the instruction itself,
+         but are only associated with the address.  */
+      type = irel->r_type;
+      if (type == R_SH_ALIGN
+	  || type == R_SH_CODE
+	  || type == R_SH_DATA
+	  || type == R_SH_LABEL)
+	continue;
+
+      /* If an R_SH_USES reloc points to one of the addresses being
+         swapped, we must adjust it.  It would be incorrect to do this
+         for a jump, though, since we want to execute both
+         instructions after the jump.  (We have avoided swapping
+         around a label, so the jump will not wind up executing an
+         instruction it shouldn't).  */
+      if (type == R_SH_USES)
+	{
+	  bfd_vma off;
+
+	  off = irel->r_vaddr - sec->vma + 4 + irel->r_offset;
+	  if (off == addr)
+	    irel->r_offset += 2;
+	  else if (off == addr + 2)
+	    irel->r_offset -= 2;
+	}
+
+      if (irel->r_vaddr - sec->vma == addr)
+	{
+	  irel->r_vaddr += 2;
+	  add = -2;
+	}
+      else if (irel->r_vaddr - sec->vma == addr + 2)
+	{
+	  irel->r_vaddr -= 2;
+	  add = 2;
+	}
+      else
+	add = 0;
+
+      if (add != 0)
+	{
+	  bfd_byte *loc;
+	  unsigned short insn, oinsn;
+	  boolean overflow;
+
+	  loc = contents + irel->r_vaddr - sec->vma;
+	  overflow = false;
+	  switch (type)
+	    {
+	    default:
+	      break;
+
+	    case R_SH_PCDISP8BY2:
+	    case R_SH_PCRELIMM8BY2:
+	      insn = bfd_get_16 (abfd, loc);
+	      oinsn = insn;
+	      insn += add / 2;
+	      if ((oinsn & 0xff00) != (insn & 0xff00))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, loc);
+	      break;
+
+	    case R_SH_PCDISP:
+	      insn = bfd_get_16 (abfd, loc);
+	      oinsn = insn;
+	      insn += add / 2;
+	      if ((oinsn & 0xf000) != (insn & 0xf000))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, loc);
+	      break;
+
+	    case R_SH_PCRELIMM8BY4:
+	      /* This reloc ignores the least significant 3 bits of
+                 the program counter before adding in the offset.
+                 This means that if ADDR is at an even address, the
+                 swap will not affect the offset.  If ADDR is an at an
+                 odd address, then the instruction will be crossing a
+                 four byte boundary, and must be adjusted.  */
+	      if ((addr & 3) != 0)
+		{
+		  insn = bfd_get_16 (abfd, loc);
+		  oinsn = insn;
+		  insn += add / 2;
+		  if ((oinsn & 0xff00) != (insn & 0xff00))
+		    overflow = true;
+		  bfd_put_16 (abfd, (bfd_vma) insn, loc);
+		}
+
+	      break;
+	    }
+
+	  if (overflow)
+	    {
+	      ((*_bfd_error_handler)
+	       ("%s: 0x%lx: fatal: reloc overflow while relaxing",
+		bfd_archive_filename (abfd), (unsigned long) irel->r_vaddr));
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+	}
+    }
+
+  return true;
+}
+
+/* This is a modification of _bfd_coff_generic_relocate_section, which
+   will handle SH relaxing.  */
+
+static boolean
+sh_relocate_section (output_bfd, info, input_bfd, input_section, contents,
+		     relocs, syms, sections)
+     bfd *output_bfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *info;
+     bfd *input_bfd;
+     asection *input_section;
+     bfd_byte *contents;
+     struct internal_reloc *relocs;
+     struct internal_syment *syms;
+     asection **sections;
+{
+  struct internal_reloc *rel;
+  struct internal_reloc *relend;
+
+  rel = relocs;
+  relend = rel + input_section->reloc_count;
+  for (; rel < relend; rel++)
+    {
+      long symndx;
+      struct coff_link_hash_entry *h;
+      struct internal_syment *sym;
+      bfd_vma addend;
+      bfd_vma val;
+      reloc_howto_type *howto;
+      bfd_reloc_status_type rstat;
+
+      /* Almost all relocs have to do with relaxing.  If any work must
+         be done for them, it has been done in sh_relax_section.  */
+      if (rel->r_type != R_SH_IMM32
+#ifdef COFF_WITH_PE
+	  && rel->r_type != R_SH_IMM32CE
+	  && rel->r_type != R_SH_IMAGEBASE
+#endif
+	  && rel->r_type != R_SH_PCDISP)
+	continue;
+
+      symndx = rel->r_symndx;
+
+      if (symndx == -1)
+	{
+	  h = NULL;
+	  sym = NULL;
+	}
+      else
+	{
+	  if (symndx < 0
+	      || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
+	    {
+	      (*_bfd_error_handler)
+		("%s: illegal symbol index %ld in relocs",
+		 bfd_archive_filename (input_bfd), symndx);
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+	  h = obj_coff_sym_hashes (input_bfd)[symndx];
+	  sym = syms + symndx;
+	}
+
+      if (sym != NULL && sym->n_scnum != 0)
+	addend = - sym->n_value;
+      else
+	addend = 0;
+
+      if (rel->r_type == R_SH_PCDISP)
+	addend -= 4;
+
+      if (rel->r_type >= SH_COFF_HOWTO_COUNT)
+	howto = NULL;
+      else
+	howto = &sh_coff_howtos[rel->r_type];
+
+      if (howto == NULL)
+	{
+	  bfd_set_error (bfd_error_bad_value);
+	  return false;
+	}
+
+#ifdef COFF_WITH_PE
+      if (rel->r_type == R_SH_IMAGEBASE)
+	addend -= pe_data (input_section->output_section->owner)->pe_opthdr.ImageBase;
+#endif
+
+      val = 0;
+
+      if (h == NULL)
+	{
+	  asection *sec;
+
+	  /* There is nothing to do for an internal PCDISP reloc.  */
+	  if (rel->r_type == R_SH_PCDISP)
+	    continue;
+
+	  if (symndx == -1)
+	    {
+	      sec = bfd_abs_section_ptr;
+	      val = 0;
+	    }
+	  else
+	    {
+	      sec = sections[symndx];
+              val = (sec->output_section->vma
+		     + sec->output_offset
+		     + sym->n_value
+		     - sec->vma);
+	    }
+	}
+      else
+	{
+	  if (h->root.type == bfd_link_hash_defined
+	      || h->root.type == bfd_link_hash_defweak)
+	    {
+	      asection *sec;
+
+	      sec = h->root.u.def.section;
+	      val = (h->root.u.def.value
+		     + sec->output_section->vma
+		     + sec->output_offset);
+	    }
+	  else if (! info->relocateable)
+	    {
+	      if (! ((*info->callbacks->undefined_symbol)
+		     (info, h->root.root.string, input_bfd, input_section,
+		      rel->r_vaddr - input_section->vma, true)))
+		return false;
+	    }
+	}
+
+      rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
+					contents,
+					rel->r_vaddr - input_section->vma,
+					val, addend);
+
+      switch (rstat)
+	{
+	default:
+	  abort ();
+	case bfd_reloc_ok:
+	  break;
+	case bfd_reloc_overflow:
+	  {
+	    const char *name;
+	    char buf[SYMNMLEN + 1];
+
+	    if (symndx == -1)
+	      name = "*ABS*";
+	    else if (h != NULL)
+	      name = h->root.root.string;
+	    else if (sym->_n._n_n._n_zeroes == 0
+		     && sym->_n._n_n._n_offset != 0)
+	      name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
+	    else
+	      {
+ 		strncpy (buf, sym->_n._n_name, SYMNMLEN);
+		buf[SYMNMLEN] = '\0';
+		name = buf;
+	      }
+
+	    if (! ((*info->callbacks->reloc_overflow)
+		   (info, name, howto->name, (bfd_vma) 0, input_bfd,
+		    input_section, rel->r_vaddr - input_section->vma)))
+	      return false;
+	  }
+	}
+    }
+
+  return true;
+}
+
+/* This is a version of bfd_generic_get_relocated_section_contents
+   which uses sh_relocate_section.  */
+
+static bfd_byte *
+sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order,
+					data, relocateable, symbols)
+     bfd *output_bfd;
+     struct bfd_link_info *link_info;
+     struct bfd_link_order *link_order;
+     bfd_byte *data;
+     boolean relocateable;
+     asymbol **symbols;
+{
+  asection *input_section = link_order->u.indirect.section;
+  bfd *input_bfd = input_section->owner;
+  asection **sections = NULL;
+  struct internal_reloc *internal_relocs = NULL;
+  struct internal_syment *internal_syms = NULL;
+
+  /* We only need to handle the case of relaxing, or of having a
+     particular set of section contents, specially.  */
+  if (relocateable
+      || coff_section_data (input_bfd, input_section) == NULL
+      || coff_section_data (input_bfd, input_section)->contents == NULL)
+    return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
+						       link_order, data,
+						       relocateable,
+						       symbols);
+
+  memcpy (data, coff_section_data (input_bfd, input_section)->contents,
+	  (size_t) input_section->_raw_size);
+
+  if ((input_section->flags & SEC_RELOC) != 0
+      && input_section->reloc_count > 0)
+    {
+      bfd_size_type symesz = bfd_coff_symesz (input_bfd);
+      bfd_byte *esym, *esymend;
+      struct internal_syment *isymp;
+      asection **secpp;
+      bfd_size_type amt;
+
+      if (! _bfd_coff_get_external_symbols (input_bfd))
+	goto error_return;
+
+      internal_relocs = (_bfd_coff_read_internal_relocs
+			 (input_bfd, input_section, false, (bfd_byte *) NULL,
+			  false, (struct internal_reloc *) NULL));
+      if (internal_relocs == NULL)
+	goto error_return;
+
+      amt = obj_raw_syment_count (input_bfd);
+      amt *= sizeof (struct internal_syment);
+      internal_syms = (struct internal_syment *) bfd_malloc (amt);
+      if (internal_syms == NULL)
+	goto error_return;
+
+      amt = obj_raw_syment_count (input_bfd);
+      amt *= sizeof (asection *);
+      sections = (asection **) bfd_malloc (amt);
+      if (sections == NULL)
+	goto error_return;
+
+      isymp = internal_syms;
+      secpp = sections;
+      esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
+      esymend = esym + obj_raw_syment_count (input_bfd) * symesz;
+      while (esym < esymend)
+	{
+	  bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
+
+	  if (isymp->n_scnum != 0)
+	    *secpp = coff_section_from_bfd_index (input_bfd, isymp->n_scnum);
+	  else
+	    {
+	      if (isymp->n_value == 0)
+		*secpp = bfd_und_section_ptr;
+	      else
+		*secpp = bfd_com_section_ptr;
+	    }
+
+	  esym += (isymp->n_numaux + 1) * symesz;
+	  secpp += isymp->n_numaux + 1;
+	  isymp += isymp->n_numaux + 1;
+	}
+
+      if (! sh_relocate_section (output_bfd, link_info, input_bfd,
+				 input_section, data, internal_relocs,
+				 internal_syms, sections))
+	goto error_return;
+
+      free (sections);
+      sections = NULL;
+      free (internal_syms);
+      internal_syms = NULL;
+      free (internal_relocs);
+      internal_relocs = NULL;
+    }
+
+  return data;
+
+ error_return:
+  if (internal_relocs != NULL)
+    free (internal_relocs);
+  if (internal_syms != NULL)
+    free (internal_syms);
+  if (sections != NULL)
+    free (sections);
+  return NULL;
+}
+
+/* The target vectors.  */
+
+#ifndef TARGET_SHL_SYM
+CREATE_BIG_COFF_TARGET_VEC (shcoff_vec, "coff-sh", BFD_IS_RELAXABLE, 0, '_', NULL)
+#endif
+
+#ifdef TARGET_SHL_SYM
+#define TARGET_SYM TARGET_SHL_SYM
+#else
+#define TARGET_SYM shlcoff_vec
+#endif
+
+#ifndef TARGET_SHL_NAME
+#define TARGET_SHL_NAME "coff-shl"
+#endif
+
+#ifdef COFF_WITH_PE
+CREATE_LITTLE_COFF_TARGET_VEC (TARGET_SYM, TARGET_SHL_NAME, BFD_IS_RELAXABLE,
+			       SEC_CODE | SEC_DATA, '_', NULL);
+#else
+CREATE_LITTLE_COFF_TARGET_VEC (TARGET_SYM, TARGET_SHL_NAME, BFD_IS_RELAXABLE,
+			       0, '_', NULL)
+#endif
+
+#ifndef TARGET_SHL_SYM
+static const bfd_target * coff_small_object_p PARAMS ((bfd *));
+static boolean coff_small_new_section_hook PARAMS ((bfd *, asection *));
+/* Some people want versions of the SH COFF target which do not align
+   to 16 byte boundaries.  We implement that by adding a couple of new
+   target vectors.  These are just like the ones above, but they
+   change the default section alignment.  To generate them in the
+   assembler, use -small.  To use them in the linker, use -b
+   coff-sh{l}-small and -oformat coff-sh{l}-small.
+
+   Yes, this is a horrible hack.  A general solution for setting
+   section alignment in COFF is rather complex.  ELF handles this
+   correctly.  */
+
+/* Only recognize the small versions if the target was not defaulted.
+   Otherwise we won't recognize the non default endianness.  */
+
+static const bfd_target *
+coff_small_object_p (abfd)
+     bfd *abfd;
+{
+  if (abfd->target_defaulted)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return NULL;
+    }
+  return coff_object_p (abfd);
+}
+
+/* Set the section alignment for the small versions.  */
+
+static boolean
+coff_small_new_section_hook (abfd, section)
+     bfd *abfd;
+     asection *section;
+{
+  if (! coff_new_section_hook (abfd, section))
+    return false;
+
+  /* We must align to at least a four byte boundary, because longword
+     accesses must be on a four byte boundary.  */
+  if (section->alignment_power == COFF_DEFAULT_SECTION_ALIGNMENT_POWER)
+    section->alignment_power = 2;
+
+  return true;
+}
+
+/* This is copied from bfd_coff_std_swap_table so that we can change
+   the default section alignment power.  */
+
+static const bfd_coff_backend_data bfd_coff_small_swap_table =
+{
+  coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
+  coff_swap_aux_out, coff_swap_sym_out,
+  coff_swap_lineno_out, coff_swap_reloc_out,
+  coff_swap_filehdr_out, coff_swap_aouthdr_out,
+  coff_swap_scnhdr_out,
+  FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
+#ifdef COFF_LONG_FILENAMES
+  true,
+#else
+  false,
+#endif
+#ifdef COFF_LONG_SECTION_NAMES
+  true,
+#else
+  false,
+#endif
+  2,
+#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
+  true,
+#else
+  false,
+#endif
+#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
+  4,
+#else
+  2,
+#endif
+  coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
+  coff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
+  coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
+  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
+  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
+  coff_classify_symbol, coff_compute_section_file_positions,
+  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
+  coff_adjust_symndx, coff_link_add_one_symbol,
+  coff_link_output_has_begun, coff_final_link_postscript
+};
+
+#define coff_small_close_and_cleanup \
+  coff_close_and_cleanup
+#define coff_small_bfd_free_cached_info \
+  coff_bfd_free_cached_info
+#define coff_small_get_section_contents \
+  coff_get_section_contents
+#define coff_small_get_section_contents_in_window \
+  coff_get_section_contents_in_window
+
+extern const bfd_target shlcoff_small_vec;
+
+const bfd_target shcoff_small_vec =
+{
+  "coff-sh-small",		/* name */
+  bfd_target_coff_flavour,
+  BFD_ENDIAN_BIG,		/* data byte order is big */
+  BFD_ENDIAN_BIG,		/* header byte order is big */
+
+  (HAS_RELOC | EXEC_P |		/* object flags */
+   HAS_LINENO | HAS_DEBUG |
+   HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE),
+
+  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),
+  '_',				/* leading symbol underscore */
+  '/',				/* ar_pad_char */
+  15,				/* ar_max_namelen */
+  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
+  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
+
+  {_bfd_dummy_target, coff_small_object_p, /* bfd_check_format */
+     bfd_generic_archive_p, _bfd_dummy_target},
+  {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
+     bfd_false},
+  {bfd_false, coff_write_object_contents, /* bfd_write_contents */
+     _bfd_write_archive_contents, bfd_false},
+
+  BFD_JUMP_TABLE_GENERIC (coff_small),
+  BFD_JUMP_TABLE_COPY (coff),
+  BFD_JUMP_TABLE_CORE (_bfd_nocore),
+  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
+  BFD_JUMP_TABLE_SYMBOLS (coff),
+  BFD_JUMP_TABLE_RELOCS (coff),
+  BFD_JUMP_TABLE_WRITE (coff),
+  BFD_JUMP_TABLE_LINK (coff),
+  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+
+  & shlcoff_small_vec,
+
+  (PTR) &bfd_coff_small_swap_table
+};
+
+const bfd_target shlcoff_small_vec =
+{
+  "coff-shl-small",		/* name */
+  bfd_target_coff_flavour,
+  BFD_ENDIAN_LITTLE,		/* data byte order is little */
+  BFD_ENDIAN_LITTLE,		/* header byte order is little endian too*/
+
+  (HAS_RELOC | EXEC_P |		/* object flags */
+   HAS_LINENO | HAS_DEBUG |
+   HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE),
+
+  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),
+  '_',				/* leading symbol underscore */
+  '/',				/* ar_pad_char */
+  15,				/* ar_max_namelen */
+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
+  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
+  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
+
+  {_bfd_dummy_target, coff_small_object_p, /* bfd_check_format */
+     bfd_generic_archive_p, _bfd_dummy_target},
+  {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
+     bfd_false},
+  {bfd_false, coff_write_object_contents, /* bfd_write_contents */
+     _bfd_write_archive_contents, bfd_false},
+
+  BFD_JUMP_TABLE_GENERIC (coff_small),
+  BFD_JUMP_TABLE_COPY (coff),
+  BFD_JUMP_TABLE_CORE (_bfd_nocore),
+  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
+  BFD_JUMP_TABLE_SYMBOLS (coff),
+  BFD_JUMP_TABLE_RELOCS (coff),
+  BFD_JUMP_TABLE_WRITE (coff),
+  BFD_JUMP_TABLE_LINK (coff),
+  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+
+  & shcoff_small_vec,
+
+  (PTR) &bfd_coff_small_swap_table
+};
+#endif
diff --git a/contrib/binutils/bfd/coffcode.h b/contrib/binutils/bfd/coffcode.h
index 212c5c6..1c02dcb 100644
--- a/contrib/binutils/bfd/coffcode.h
+++ b/contrib/binutils/bfd/coffcode.h
@@ -1246,7 +1246,7 @@ Special entry points for gdb to swap in coff symbol table parts:
 .	     struct coff_link_hash_entry *, struct internal_syment *,
 .	     bfd_vma *));
 .
-.  boolean (*_bfd_coff_adjust_symndx)\
+.  boolean (*_bfd_coff_adjust_symndx)
 .    PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
 .	     struct internal_reloc *, boolean *));
 .
diff --git a/contrib/binutils/bfd/coffgen.c b/contrib/binutils/bfd/coffgen.c
index ee6c8fc..21589c6 100644
--- a/contrib/binutils/bfd/coffgen.c
+++ b/contrib/binutils/bfd/coffgen.c
@@ -2196,7 +2196,7 @@ _bfd_coff_is_local_label_name (abfd, name)
      bfd *abfd ATTRIBUTE_UNUSED;
      const char *name;
 {
-  return name[0] == '.' && name[1] == 'L';
+  return (boolean) (name[0] == '.' && name[1] == 'L');
 }
 
 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
diff --git a/contrib/binutils/bfd/cofflink.c b/contrib/binutils/bfd/cofflink.c
index eb9388f..c1302ee 100644
--- a/contrib/binutils/bfd/cofflink.c
+++ b/contrib/binutils/bfd/cofflink.c
@@ -1322,6 +1322,9 @@ mark_relocs (finfo, input_bfd)
 
       if ((a->flags & SEC_RELOC) == 0 || a->reloc_count  < 1)
 	continue;
+      /* Don't mark relocs in excluded sections.  */
+      if (a->output_section == bfd_abs_section_ptr)
+	continue;
 
       /* Read in the relocs.  */
       internal_relocs = _bfd_coff_read_internal_relocs
diff --git a/contrib/binutils/bfd/config.bfd b/contrib/binutils/bfd/config.bfd
index 184bbef..2e9d7fa 100755
--- a/contrib/binutils/bfd/config.bfd
+++ b/contrib/binutils/bfd/config.bfd
@@ -359,8 +359,8 @@ case "${targ}" in
     targ_defvec=bfd_elf32_i386_vec
     targ_selvecs=i386coff_vec
     ;;
-  i[3456]86-*-nto-qnx*)
-    targ_defvec=bfd_elf32_i386qnx_vec
+  i[3456]86-*-nto*)
+    targ_defvec=bfd_elf32_i386_vec
     targ_selvecs=i386coff_vec
     ;;
   i[3456]86-*-chorus*)
@@ -888,10 +888,12 @@ case "${targ}" in
 
   s390-*-linux*)
     targ_defvec=bfd_elf32_s390_vec
+    targ64_selvecs=bfd_elf64_s390_vec
     ;;
 #ifdef BFD64
   s390x-*-linux*)
     targ_defvec=bfd_elf64_s390_vec
+    targ_selvecs=bfd_elf32_s390_vec
     ;;
 #endif
 
@@ -925,9 +927,11 @@ case "${targ}" in
     ;;
   sh*eb-*-linux*)
     targ_defvec=bfd_elf32_shblin_vec
+    targ_selvecs=bfd_elf32_shlin_vec
     ;;
   sh*-*-linux*)
     targ_defvec=bfd_elf32_shlin_vec
+    targ_selvecs=bfd_elf32_shblin_vec
     ;;
 
 #ifdef BFD64
diff --git a/contrib/binutils/bfd/config.in b/contrib/binutils/bfd/config.in
index 222096e..d13d196 100644
--- a/contrib/binutils/bfd/config.in
+++ b/contrib/binutils/bfd/config.in
@@ -1,4 +1,4 @@
-/* config.in.  Generated automatically from configure.in by autoheader.  */
+/* config.in.  Generated automatically from configure.in by autoheader 2.13.  */
 
 /* Define if using alloca.c.  */
 #undef C_ALLOCA
@@ -160,15 +160,9 @@
 /* Define if you have the <sys/procfs.h> header file.  */
 #undef HAVE_SYS_PROCFS_H
 
-/* Define if you have the <sys/stat.h> header file.  */
-#undef HAVE_SYS_STAT_H
-
 /* Define if you have the <sys/time.h> header file.  */
 #undef HAVE_SYS_TIME_H
 
-/* Define if you have the <sys/types.h> header file.  */
-#undef HAVE_SYS_TYPES_H
-
 /* Define if you have the <time.h> header file.  */
 #undef HAVE_TIME_H
 
diff --git a/contrib/binutils/bfd/configure b/contrib/binutils/bfd/configure
index 6d12109..2eca955 100755
--- a/contrib/binutils/bfd/configure
+++ b/contrib/binutils/bfd/configure
@@ -1118,7 +1118,7 @@ fi
 
 PACKAGE=bfd
 
-VERSION=2.13
+VERSION=2.13.1
 
 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
@@ -6063,7 +6063,6 @@ do
     bfd_elf32_i370_vec)		tb="$tb elf32-i370.lo elf32.lo $elf" ;;
     bfd_elf32_i386_freebsd_vec)	tb="$tb elf32-i386-fbsd.lo elf32.lo $elf" ;;
     bfd_elf32_i386_vec)		tb="$tb elf32-i386.lo elf32.lo $elf" ;;
-    bfd_elf32_i386qnx_vec)	tb="$tb elf32-i386qnx.lo elf32.lo $elf" ;;
     bfd_elf32_i860_little_vec)	tb="$tb elf32-i860.lo elf32.lo $elf" ;;
     bfd_elf32_i860_vec)		tb="$tb elf32-i860.lo elf32.lo $elf" ;;
     bfd_elf32_i960_vec)		tb="$tb elf32-i960.lo elf32.lo $elf" ;;
@@ -6310,10 +6309,10 @@ case ${host64}-${target64}-${want64} in
     if test -n "$GCC" ; then
        bad_64bit_gcc=no;
        echo $ac_n "checking for gcc version with buggy 64-bit support""... $ac_c" 1>&6
-echo "configure:6314: checking for gcc version with buggy 64-bit support" >&5
+echo "configure:6313: checking for gcc version with buggy 64-bit support" >&5
        # Add more tests for gcc versions with non-working 64-bit support here.
        cat > conftest.$ac_ext <<EOF
-#line 6317 "configure"
+#line 6316 "configure"
 #include "confdefs.h"
 :__GNUC__:__GNUC_MINOR__:__i386__:
 EOF
@@ -6358,17 +6357,17 @@ for ac_hdr in unistd.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:6362: checking for $ac_hdr" >&5
+echo "configure:6361: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 6367 "configure"
+#line 6366 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:6372: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:6371: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -6397,12 +6396,12 @@ done
 for ac_func in getpagesize
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6401: checking for $ac_func" >&5
+echo "configure:6400: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 6406 "configure"
+#line 6405 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -6425,7 +6424,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:6429: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6428: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -6450,7 +6449,7 @@ fi
 done
 
 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:6454: checking for working mmap" >&5
+echo "configure:6453: checking for working mmap" >&5
 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -6458,7 +6457,7 @@ else
   ac_cv_func_mmap_fixed_mapped=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 6462 "configure"
+#line 6461 "configure"
 #include "confdefs.h"
 
 /* Thanks to Mike Haertel and Jim Avera for this test.
@@ -6598,7 +6597,7 @@ main()
 }
 
 EOF
-if { (eval echo configure:6602: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:6601: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_mmap_fixed_mapped=yes
 else
@@ -6623,12 +6622,12 @@ fi
 for ac_func in madvise mprotect
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6627: checking for $ac_func" >&5
+echo "configure:6626: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 6632 "configure"
+#line 6631 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -6651,7 +6650,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:6655: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6654: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
diff --git a/contrib/binutils/bfd/configure.in b/contrib/binutils/bfd/configure.in
index 22292f2..4db2520 100644
--- a/contrib/binutils/bfd/configure.in
+++ b/contrib/binutils/bfd/configure.in
@@ -7,7 +7,7 @@ AC_INIT(libbfd.c)
 AC_CANONICAL_SYSTEM
 AC_ISC_POSIX
 
-AM_INIT_AUTOMAKE(bfd, 2.13)
+AM_INIT_AUTOMAKE(bfd, 2.13.1)
 # Uncomment the next line to remove the date from the reported bfd version
 # is_release=y
 
@@ -577,7 +577,6 @@ do
     bfd_elf32_i370_vec)		tb="$tb elf32-i370.lo elf32.lo $elf" ;;
     bfd_elf32_i386_freebsd_vec)	tb="$tb elf32-i386-fbsd.lo elf32.lo $elf" ;;
     bfd_elf32_i386_vec)		tb="$tb elf32-i386.lo elf32.lo $elf" ;;
-    bfd_elf32_i386qnx_vec)	tb="$tb elf32-i386qnx.lo elf32.lo $elf" ;;
     bfd_elf32_i860_little_vec)	tb="$tb elf32-i860.lo elf32.lo $elf" ;;
     bfd_elf32_i860_vec)		tb="$tb elf32-i860.lo elf32.lo $elf" ;;
     bfd_elf32_i960_vec)		tb="$tb elf32-i960.lo elf32.lo $elf" ;;
diff --git a/contrib/binutils/bfd/cpu-sh.c b/contrib/binutils/bfd/cpu-sh.c
new file mode 100644
index 0000000..dff2f88
--- /dev/null
+++ b/contrib/binutils/bfd/cpu-sh.c
@@ -0,0 +1,168 @@
+/* BFD library support routines for the Hitachi-SH architecture.
+   Copyright 1993, 1994, 1997, 1998, 2000, 2001
+   Free Software Foundation, Inc.
+   Hacked by Steve Chamberlain of Cygnus Support.
+
+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"
+
+#if 0
+/* This routine is provided two arch_infos and returns whether
+   they'd be compatible */
+
+static const bfd_arch_info_type *
+compatible (a,b)
+     const bfd_arch_info_type *a;
+     const bfd_arch_info_type *b;
+{
+  if (a->arch != b->arch || a->mach != b->mach)
+   return NULL;
+  return a;
+}
+#endif
+
+#define SH_NEXT      &arch_info_struct[0]
+#define SH2_NEXT     &arch_info_struct[1]
+#define SH_DSP_NEXT  &arch_info_struct[2]
+#define SH3_NEXT     &arch_info_struct[3]
+#define SH3_DSP_NEXT &arch_info_struct[4]
+#define SH3E_NEXT    &arch_info_struct[5]
+#define SH4_NEXT     NULL
+#undef  SH4_NEXT
+#define SH4_NEXT     &arch_info_struct[6]
+#define SH64_NEXT    NULL
+
+static const bfd_arch_info_type arch_info_struct[] =
+{
+  {
+    32,				/* 32 bits in a word */
+    32,				/* 32 bits in an address */
+    8,				/* 8 bits in a byte */
+    bfd_arch_sh,
+    bfd_mach_sh2,
+    "sh",			/* arch_name  */
+    "sh2",			/* printable name */
+    1,
+    false,			/* not the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    SH2_NEXT
+  },
+  {
+    32,				/* 32 bits in a word */
+    32,				/* 32 bits in an address */
+    8,				/* 8 bits in a byte */
+    bfd_arch_sh,
+    bfd_mach_sh_dsp,
+    "sh",			/* arch_name  */
+    "sh-dsp",			/* printable name */
+    1,
+    false,			/* not the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    SH_DSP_NEXT
+  },
+  {
+    32,				/* 32 bits in a word */
+    32,				/* 32 bits in an address */
+    8,				/* 8 bits in a byte */
+    bfd_arch_sh,
+    bfd_mach_sh3,
+    "sh",			/* arch_name  */
+    "sh3",			/* printable name */
+    1,
+    false,			/* not the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    SH3_NEXT
+  },
+  {
+    32,				/* 32 bits in a word */
+    32,				/* 32 bits in an address */
+    8,				/* 8 bits in a byte */
+    bfd_arch_sh,
+    bfd_mach_sh3_dsp,
+    "sh",			/* arch_name  */
+    "sh3-dsp",			/* printable name */
+    1,
+    false,			/* not the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    SH3_DSP_NEXT
+  },
+  {
+    32,				/* 32 bits in a word */
+    32,				/* 32 bits in an address */
+    8,				/* 8 bits in a byte */
+    bfd_arch_sh,
+    bfd_mach_sh3e,
+    "sh",			/* arch_name  */
+    "sh3e",			/* printable name */
+    1,
+    false,			/* not the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    SH3E_NEXT
+  },
+  {
+    32,				/* 32 bits in a word */
+    32,				/* 32 bits in an address */
+    8,				/* 8 bits in a byte */
+    bfd_arch_sh,
+    bfd_mach_sh4,
+    "sh",			/* arch_name  */
+    "sh4",			/* printable name */
+    1,
+    false,			/* not the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    SH4_NEXT
+  },
+  {
+    64,				/* 64 bits in a word */
+    64,				/* 64 bits in an address */
+    8,				/* 8 bits in a byte */
+    bfd_arch_sh,
+    bfd_mach_sh5,
+    "sh",			/* arch_name  */
+    "sh5",			/* printable name */
+    1,
+    false,			/* not the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    SH64_NEXT
+  },
+};
+
+const bfd_arch_info_type bfd_sh_arch =
+{
+  32,				/* 32 bits in a word */
+  32,				/* 32 bits in an address */
+  8,				/* 8 bits in a byte */
+  bfd_arch_sh,
+  bfd_mach_sh,
+  "sh",				/* arch_name  */
+  "sh",				/* printable name */
+  1,
+  true,				/* the default machine */
+  bfd_default_compatible,
+  bfd_default_scan,
+  SH_NEXT
+};
diff --git a/contrib/binutils/bfd/doc/Makefile.in b/contrib/binutils/bfd/doc/Makefile.in
index 8daf537..f35cc9a 100644
--- a/contrib/binutils/bfd/doc/Makefile.in
+++ b/contrib/binutils/bfd/doc/Makefile.in
@@ -1,6 +1,6 @@
-# Makefile.in generated automatically by automake 1.4-p5 from Makefile.am
+# Makefile.in generated automatically by automake 1.4 from Makefile.am
 
-# Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc.
+# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
@@ -330,7 +330,7 @@ uninstall-info:
 	else ii=; fi; \
 	list='$(INFO_DEPS)'; \
 	for file in $$list; do \
-	  test -z "$$ii" \
+	  test -z "$ii" \
 	    || install-info --info-dir=$(DESTDIR)$(infodir) --remove $$file; \
 	done
 	@$(NORMAL_UNINSTALL)
diff --git a/contrib/binutils/bfd/doc/bfdt.texi b/contrib/binutils/bfd/doc/bfdt.texi
index a6e0ad9..46bb61a 100644
--- a/contrib/binutils/bfd/doc/bfdt.texi
+++ b/contrib/binutils/bfd/doc/bfdt.texi
@@ -104,6 +104,9 @@ struct _bfd
   /* Symbol table for output BFD (with symcount entries).  */
   struct symbol_cache_entry  **outsymbols;
 
+  /* Used for slurped dynamic symbol tables.  */
+  unsigned int dynsymcount;
+
   /* Pointer to structure which contains architecture information.  */
   const struct bfd_arch_info *arch_info;
 
@@ -661,12 +664,12 @@ extern bfd_byte *bfd_get_relocated_section_contents
 @subsubsection @code{bfd_alt_mach_code}
 @strong{Synopsis}
 @example
-boolean bfd_alt_mach_code(bfd *abfd, int index);
+boolean bfd_alt_mach_code(bfd *abfd, int alternative);
 @end example
 @strong{Description}@*
 When more than one machine code number is available for the
 same machine type, this function can be used to switch between
-the preferred one (index == 0) and any others.  Currently,
+the preferred one (alternative == 0) and any others.  Currently,
 only ELF supports this feature, with up to two alternate
 machine codes.
 
diff --git a/contrib/binutils/bfd/doc/coffcode.texi b/contrib/binutils/bfd/doc/coffcode.texi
index e7c9d77..473747e 100644
--- a/contrib/binutils/bfd/doc/coffcode.texi
+++ b/contrib/binutils/bfd/doc/coffcode.texi
@@ -398,7 +398,7 @@ typedef struct
             struct coff_link_hash_entry *, struct internal_syment *,
             bfd_vma *));
 
-  boolean (*_bfd_coff_adjust_symndx)\
+  boolean (*_bfd_coff_adjust_symndx)
     PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
             struct internal_reloc *, boolean *));
 
diff --git a/contrib/binutils/bfd/doc/reloc.texi b/contrib/binutils/bfd/doc/reloc.texi
index 456fc29..1ebd430 100644
--- a/contrib/binutils/bfd/doc/reloc.texi
+++ b/contrib/binutils/bfd/doc/reloc.texi
@@ -804,6 +804,9 @@ MIPS ELF relocations.
 @deffnx {} BFD_RELOC_386_RELATIVE
 @deffnx {} BFD_RELOC_386_GOTOFF
 @deffnx {} BFD_RELOC_386_GOTPC
+@deffnx {} BFD_RELOC_386_TLS_TPOFF
+@deffnx {} BFD_RELOC_386_TLS_IE
+@deffnx {} BFD_RELOC_386_TLS_GOTIE
 @deffnx {} BFD_RELOC_386_TLS_LE
 @deffnx {} BFD_RELOC_386_TLS_GD
 @deffnx {} BFD_RELOC_386_TLS_LDM
diff --git a/contrib/binutils/bfd/dwarf2.c b/contrib/binutils/bfd/dwarf2.c
index 5aadadd..0639826 100644
--- a/contrib/binutils/bfd/dwarf2.c
+++ b/contrib/binutils/bfd/dwarf2.c
@@ -402,7 +402,7 @@ read_indirect_string (unit, buf, bytes_read_ptr)
       return NULL;
     }
 
-  buf = stash->dwarf_str_buffer + offset;  
+  buf = stash->dwarf_str_buffer + offset;
   if (*buf == '\0')
     return NULL;
   return buf;
@@ -578,7 +578,8 @@ read_abbrevs (abfd, offset, stash)
 
       /* Read in abbrev header.  */
       cur_abbrev->number = abbrev_number;
-      cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+      cur_abbrev->tag = (enum dwarf_tag)
+	read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
       abbrev_ptr += bytes_read;
       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
       abbrev_ptr += 1;
@@ -601,8 +602,10 @@ read_abbrevs (abfd, offset, stash)
 		return 0;
 	    }
 
-	  cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
-	  cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
+	  cur_abbrev->attrs[cur_abbrev->num_attrs].name
+	    = (enum dwarf_attribute) abbrev_name;
+	  cur_abbrev->attrs[cur_abbrev->num_attrs++].form
+	    = (enum dwarf_form) abbrev_form;
 	  abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 	  abbrev_ptr += bytes_read;
 	  abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
@@ -614,7 +617,7 @@ read_abbrevs (abfd, offset, stash)
       abbrevs[hash_number] = cur_abbrev;
 
       /* Get next abbreviation.
-         Under Irix6 the abbreviations for a compilation unit are not
+	 Under Irix6 the abbreviations for a compilation unit are not
 	 always properly terminated with an abbrev number of 0.
 	 Exit loop if we encounter an abbreviation which we have
 	 already read (which means we are about to read the abbreviations
@@ -646,7 +649,7 @@ read_attribute_value (attr, form, unit, info_ptr)
   struct dwarf_block *blk;
   bfd_size_type amt;
 
-  attr->form = form;
+  attr->form = (enum dwarf_form) form;
 
   switch (form)
     {
@@ -806,7 +809,8 @@ struct line_info_table
   char* comp_dir;
   char** dirs;
   struct fileinfo* files;
-  struct line_info* last_line;
+  struct line_info* last_line;  /* largest VMA */
+  struct line_info* lcl_head;   /* local head; used in 'add_line_info' */
 };
 
 struct funcinfo
@@ -817,6 +821,11 @@ struct funcinfo
   bfd_vma high;
 };
 
+/* add_line_info: adds a new entry to the line_info list in the
+   line_info_table, ensuring that the list is sorted.  Note that the
+   line_info list is sorted from highest to lowest VMA (with possible
+   duplicates); that is, line_info->prev_line always accesses an equal
+   or smaller VMA.  */
 static void
 add_line_info (table, address, filename, line, column, end_sequence)
      struct line_info_table* table;
@@ -829,9 +838,72 @@ add_line_info (table, address, filename, line, column, end_sequence)
   bfd_size_type amt = sizeof (struct line_info);
   struct line_info* info = (struct line_info*) bfd_alloc (table->abfd, amt);
 
-  info->prev_line = table->last_line;
-  table->last_line = info;
+  /* Find the correct location for 'info'.  Normally we will receive
+     new line_info data 1) in order and 2) with increasing VMAs.
+     However some compilers break the rules (cf. decode_line_info) and
+     so we include some heuristics for quickly finding the correct
+     location for 'info'. In particular, these heuristics optimize for
+     the common case in which the VMA sequence that we receive is a
+     list of locally sorted VMAs such as
+       p...z a...j  (where a < j < p < z)
 
+     Note: table->lcl_head is used to head an *actual* or *possible*
+     sequence within the list (such as a...j) that is not directly
+     headed by table->last_line
+
+     Note: we may receive duplicate entries from 'decode_line_info'.  */
+
+  while (1)
+    if (!table->last_line
+	|| address >= table->last_line->address)
+      {
+	/* Normal case: add 'info' to the beginning of the list */
+	info->prev_line = table->last_line;
+	table->last_line = info;
+
+	/* lcl_head: initialize to head a *possible* sequence at the end.  */
+	if (!table->lcl_head)
+	  table->lcl_head = info;
+	break;
+      }
+    else if (!table->lcl_head->prev_line
+	     && table->lcl_head->address > address)
+      {
+	/* Abnormal but easy: lcl_head is 1) at the *end* of the line
+	   list and 2) the head of 'info'.  */
+	info->prev_line = NULL;
+	table->lcl_head->prev_line = info;
+	break;
+      }
+    else if (table->lcl_head->prev_line
+	     && table->lcl_head->address > address
+	     && address >= table->lcl_head->prev_line->address)
+      {
+	/* Abnormal but easy: lcl_head is 1) in the *middle* of the line
+	   list and 2) the head of 'info'.  */
+	info->prev_line = table->lcl_head->prev_line;
+	table->lcl_head->prev_line = info;
+	break;
+      }
+    else
+      {
+	/* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
+	   heads for 'info'.  Reset 'lcl_head' and repeat.  */
+	struct line_info* li2 = table->last_line; /* always non-NULL */
+	struct line_info* li1 = li2->prev_line;
+
+	while (li1)
+	  {
+	    if (li2->address > address && address >= li1->address)
+	      break;
+
+	    li2 = li1; /* always non-NULL */
+	    li1 = li1->prev_line;
+	  }
+	table->lcl_head = li2;
+      }
+
+  /* Set member data of 'info'.  */
   info->address = address;
   info->filename = filename;
   info->line = line;
@@ -908,7 +980,8 @@ arange_add (unit, low_pc, high_pc)
     }
 
   /* Need to allocate a new arange and insert it into the arange list.  */
-  arange = bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
+  arange = (struct arange *)
+    bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
   arange->low = low_pc;
   arange->high = high_pc;
 
@@ -982,6 +1055,7 @@ decode_line_info (unit, stash)
 
   table->files = NULL;
   table->last_line = NULL;
+  table->lcl_head = NULL;
 
   line_ptr = stash->dwarf_line_buffer + unit->line_offset;
 
@@ -1091,10 +1165,10 @@ decode_line_info (unit, stash)
       int basic_block = 0;
       int end_sequence = 0;
       /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
-         compilers generate address sequences that are wildly out of
-         order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
-         for ia64-Linux).  Thus, to determine the low and high
-         address, we must compare on every DW_LNS_copy, etc.  */
+	 compilers generate address sequences that are wildly out of
+	 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
+	 for ia64-Linux).  Thus, to determine the low and high
+	 address, we must compare on every DW_LNS_copy, etc.  */
       bfd_vma low_pc  = 0;
       bfd_vma high_pc = 0;
 
@@ -1133,12 +1207,11 @@ decode_line_info (unit, stash)
 		  end_sequence = 1;
 		  add_line_info (table, address, filename, line, column,
 				 end_sequence);
-		  arange_add (unit, low_pc, high_pc);
 		  if (low_pc == 0 || address < low_pc)
 		    low_pc = address;
 		  if (address > high_pc)
 		    high_pc = address;
-		  arange_add (unit, low_pc, address);
+		  arange_add (unit, low_pc, high_pc);
 		  break;
 		case DW_LNE_set_address:
 		  address = read_address (unit, line_ptr);
@@ -1250,19 +1323,31 @@ lookup_address_in_line_info_table (table, addr, function, filename_ptr,
      const char **filename_ptr;
      unsigned int *linenumber_ptr;
 {
+  /* Note: table->last_line should be a descendingly sorted list. */
   struct line_info* next_line = table->last_line;
-  struct line_info* each_line;
+  struct line_info* each_line = NULL;
+  *filename_ptr = NULL;
 
   if (!next_line)
     return false;
 
   each_line = next_line->prev_line;
 
+  /* Check for large addresses */
+  if (addr > next_line->address)
+    each_line = NULL; /* ensure we skip over the normal case */
+
+  /* Normal case: search the list; save  */
   while (each_line && next_line)
     {
-      if (!each_line->end_sequence
-	  && addr >= each_line->address && addr < next_line->address)
+      /* If we have an address match, save this info.  This allows us
+	 to return as good as results as possible for strange debugging
+	 info.  */
+      boolean addr_match = false;
+      if (each_line->address <= addr && addr <= next_line->address)
 	{
+	  addr_match = true;
+
 	  /* If this line appears to span functions, and addr is in the
 	     later function, return the first line of that function instead
 	     of the last line of the earlier one.  This check is for GCC
@@ -1279,16 +1364,22 @@ lookup_address_in_line_info_table (table, addr, function, filename_ptr,
 	      *filename_ptr = each_line->filename;
 	      *linenumber_ptr = each_line->line;
 	    }
-	  return true;
 	}
+
+      if (addr_match && !each_line->end_sequence)
+	return true; /* we have definitely found what we want */
+
       next_line = each_line;
       each_line = each_line->prev_line;
     }
 
-  /* At this point each_line is NULL but next_line is not.  If we found the
-     containing function in this compilation unit, return the first line we
-     have a number for.  This is also for compatibility with GCC 2.95.  */
-  if (function != NULL)
+  /* At this point each_line is NULL but next_line is not.  If we found
+     a candidate end-of-sequence point in the loop above, we can return
+     that (compatibility with a bug in the Intel compiler); otherwise,
+     assuming that we found the containing function for this address in
+     this compilation unit, return the first line we have a number for
+     (compatibility with GCC 2.95).  */
+  if (*filename_ptr == NULL && function != NULL)
     {
       *filename_ptr = next_line->filename;
       *linenumber_ptr = next_line->line;
@@ -1646,18 +1737,18 @@ comp_unit_contains_address (unit, addr)
   struct arange *arange;
 
   if (unit->error)
-    return 0;
+    return false;
 
   arange = &unit->arange;
   do
     {
       if (addr >= arange->low && addr < arange->high)
-	return 1;
+	return true;
       arange = arange->next;
     }
   while (arange);
 
-  return 0;
+  return false;
 }
 
 /* If UNIT contains ADDR, set the output parameters to the values for
@@ -1702,7 +1793,7 @@ comp_unit_find_nearest_line (unit, addr, filename_ptr, functionname_ptr,
 	}
 
       if (unit->first_child_die_ptr < unit->end_ptr
-          && ! scan_unit_for_functions (unit))
+	  && ! scan_unit_for_functions (unit))
 	{
 	  unit->error = 1;
 	  return false;
@@ -1715,7 +1806,7 @@ comp_unit_find_nearest_line (unit, addr, filename_ptr, functionname_ptr,
   line_p = lookup_address_in_line_info_table (unit->line_table, addr,
 					      function, filename_ptr,
 					      linenumber_ptr);
-  return line_p || func_p;
+  return (boolean) (line_p || func_p);
 }
 
 /* Locate a section in a BFD containing debugging info.  The search starts
@@ -1822,7 +1913,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
 	 return false;
 
       /* There can be more than one DWARF2 info section in a BFD these days.
-         Read them all in and produce one large stash.  We do this in two
+	 Read them all in and produce one large stash.  We do this in two
 	 passes - in the first pass we just accumulate the section sizes.
 	 In the second pass we read in the section's contents.  The allows
 	 us to avoid reallocing the data as we add sections to the stash.  */
@@ -1918,7 +2009,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
       stash->info_ptr += addr_size;
 
       if (length > 0)
-        {
+	{
 	  each = parse_comp_unit (abfd, stash, length, offset_size);
 	  stash->info_ptr += length;
 
diff --git a/contrib/binutils/bfd/ecoff.c b/contrib/binutils/bfd/ecoff.c
index c8c56f8..ed10850 100644
--- a/contrib/binutils/bfd/ecoff.c
+++ b/contrib/binutils/bfd/ecoff.c
@@ -3837,7 +3837,7 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext)
     = backend->debug_swap.swap_ext_in;
   bfd_size_type external_ext_size = backend->debug_swap.external_ext_size;
   unsigned long ext_count;
-  struct ecoff_link_hash_entry **sym_hash;
+  struct bfd_link_hash_entry **sym_hash;
   char *ext_ptr;
   char *ext_end;
   bfd_size_type amt;
@@ -3846,10 +3846,10 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext)
 
   amt = ext_count;
   amt *= sizeof (struct bfd_link_hash_entry *);
-  sym_hash = (struct ecoff_link_hash_entry **) bfd_alloc (abfd, amt);
+  sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt);
   if (!sym_hash)
     return false;
-  ecoff_data (abfd)->sym_hashes = sym_hash;
+  ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
 
   ext_ptr = (char *) external_ext;
   ext_end = ext_ptr + ext_count * external_ext_size;
@@ -3980,15 +3980,13 @@ ecoff_link_add_externals (abfd, info, external_ext, ssext)
 
       name = ssext + esym.asym.iss;
 
-      h = NULL;
       if (! (_bfd_generic_link_add_one_symbol
 	     (info, abfd, name,
 	      (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL),
-	      section, value, (const char *) NULL, true, true,
-	      (struct bfd_link_hash_entry **) &h)))
+	      section, value, (const char *) NULL, true, true, sym_hash)))
 	return false;
 
-      *sym_hash = h;
+      h = (struct ecoff_link_hash_entry *) *sym_hash;
 
       /* If we are building an ECOFF hash table, save the external
 	 symbol information.  */
diff --git a/contrib/binutils/bfd/elf-bfd.h b/contrib/binutils/bfd/elf-bfd.h
index 4c7e2f6..9417623 100644
--- a/contrib/binutils/bfd/elf-bfd.h
+++ b/contrib/binutils/bfd/elf-bfd.h
@@ -770,22 +770,6 @@ struct elf_backend_data
   boolean (*elf_backend_write_section)
     PARAMS ((bfd *, asection *, bfd_byte *));
 
-  /* This function, if defined, sets  up the file positions for non PT_LOAD
-     segments, especially for segments containing non-allocated sections.  */
-  void (*set_nonloadable_filepos)
-    PARAMS ((bfd *, Elf_Internal_Phdr *));
-
-  /* This function, if defined, returns true if the section is contained
-     within the segment.  File positions are compared.  */
-  boolean (*is_contained_by_filepos)
-    PARAMS ((asection *, Elf_Internal_Phdr *));
-
-  /* This function, if defined, returns true if copy_private_bfd_data
-     should be called.  It provides a way of overriding default
-     test conditions in _bfd_elf_copy_private_section_data.  */
-  boolean (*copy_private_bfd_data_p)
-    PARAMS ((bfd *, asection *, bfd *, asection *));
-
   /* The level of IRIX compatibility we're striving for.
      MIPS ELF specific function.  */
   irix_compat_t (*elf_backend_mips_irix_compat)
diff --git a/contrib/binutils/bfd/elf-eh-frame.c b/contrib/binutils/bfd/elf-eh-frame.c
index 713dc8f..62226c5 100644
--- a/contrib/binutils/bfd/elf-eh-frame.c
+++ b/contrib/binutils/bfd/elf-eh-frame.c
@@ -414,7 +414,7 @@ _bfd_elf_discard_section_eh_frame (abfd, info, sec, ehdrsec,
 	    /* 64-bit .eh_frame is not supported.  */
 	    goto free_no_table;
 	  buf += 4;
-	  if ((buf - ehbuf) + hdr.length > sec->_raw_size)
+	  if ((bfd_size_type) (buf - ehbuf) + hdr.length > sec->_raw_size)
 	    /* CIE/FDE not contained fully in this .eh_frame input section.  */
 	    goto free_no_table;
 
diff --git a/contrib/binutils/bfd/elf.c b/contrib/binutils/bfd/elf.c
index a7bafb6..6a3a78e 100644
--- a/contrib/binutils/bfd/elf.c
+++ b/contrib/binutils/bfd/elf.c
@@ -3960,11 +3960,6 @@ Error: First section in segment (%s) starts at 0x%x whereas the segment starts a
 	}
     }
 
-  /* If additional nonloadable filepos adjustments are required,
-     do them now. */
-  if (bed->set_nonloadable_filepos)
-    (*bed->set_nonloadable_filepos) (abfd, phdrs);
-
   /* Clear out any program headers we allocated but did not use.  */
   for (; count < alloc; count++, p++)
     {
@@ -4560,13 +4555,6 @@ copy_private_bfd_data (ibfd, obfd)
    && (section->lma + section->_raw_size				\
        <= SEGMENT_END (segment, base)))
 
-  /* Returns true if the given section is contained within the
-     given segment.  Filepos addresses are compared in an elf
-     backend function. */
-#define IS_CONTAINED_BY_FILEPOS(sec, seg, bed)				\
-  (bed->is_contained_by_filepos						\
-   && (*bed->is_contained_by_filepos) (sec, seg))
-
   /* Special case: corefile "NOTE" section containing regs, prpsinfo etc.  */
 #define IS_COREFILE_NOTE(p, s)						\
   (p->p_type == PT_NOTE							\
@@ -4602,9 +4590,7 @@ copy_private_bfd_data (ibfd, obfd)
       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)	\
       : IS_CONTAINED_BY_VMA (section, segment))				\
      && (section->flags & SEC_ALLOC) != 0)				\
-    || IS_COREFILE_NOTE (segment, section)				\
-    || (IS_CONTAINED_BY_FILEPOS (section, segment, bed)			\
-        && (section->flags & SEC_ALLOC) == 0))				\
+    || IS_COREFILE_NOTE (segment, section))				\
    && section->output_section != NULL					\
    && ! section->segment_mark)
 
@@ -4849,7 +4835,6 @@ copy_private_bfd_data (ibfd, obfd)
 	      /* Match up the physical address of the segment with the
 		 LMA address of the output section.  */
 	      if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
-		  || IS_CONTAINED_BY_FILEPOS (section, segment, bed)
 		  || IS_COREFILE_NOTE (segment, section)
 		  || (bed->want_p_paddr_set_to_zero &&
 		      IS_CONTAINED_BY_VMA (output_section, segment))
@@ -5086,7 +5071,6 @@ copy_private_bfd_data (ibfd, obfd)
 #undef SEGMENT_END
 #undef IS_CONTAINED_BY_VMA
 #undef IS_CONTAINED_BY_LMA
-#undef IS_CONTAINED_BY_FILEPOS
 #undef IS_COREFILE_NOTE
 #undef IS_SOLARIS_PT_INTERP
 #undef INCLUDE_SECTION_IN_SEGMENT
@@ -5106,26 +5090,12 @@ _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
      asection *osec;
 {
   Elf_Internal_Shdr *ihdr, *ohdr;
-  const struct elf_backend_data *bed = get_elf_backend_data (ibfd);
 
   if (ibfd->xvec->flavour != bfd_target_elf_flavour
       || obfd->xvec->flavour != bfd_target_elf_flavour)
     return true;
 
-  /* Copy over private BFD data if it has not already been copied.
-     This must be done here, rather than in the copy_private_bfd_data
-     entry point, because the latter is called after the section
-     contents have been set, which means that the program headers have
-     already been worked out.  The backend function provides a way to
-     override the test conditions and code path for the call to
-     copy_private_bfd_data.  */
-  if (bed->copy_private_bfd_data_p)
-    {
-      if ((*bed->copy_private_bfd_data_p) (ibfd, isec, obfd, osec))
-        if (! copy_private_bfd_data (ibfd, obfd))
-          return false;
-    }
-  else if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
+  if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
     {
 	asection *s;
 
diff --git a/contrib/binutils/bfd/elf32-arm.h b/contrib/binutils/bfd/elf32-arm.h
index f41b843..bb193ab 100644
--- a/contrib/binutils/bfd/elf32-arm.h
+++ b/contrib/binutils/bfd/elf32-arm.h
@@ -423,6 +423,7 @@ record_arm_to_thumb_glue (link_info, h)
   asection * s;
   char * tmp_name;
   struct elf_link_hash_entry * myh;
+  struct bfd_link_hash_entry * bh;
   struct elf32_arm_link_hash_table * globals;
   bfd_vma val;
 
@@ -456,11 +457,11 @@ record_arm_to_thumb_glue (link_info, h)
   /* The only trick here is using hash_table->arm_glue_size as the value. Even
      though the section isn't allocated yet, this is where we will be putting
      it.  */
+  bh = NULL;
   val = globals->arm_glue_size + 1;
   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
 				    tmp_name, BSF_GLOBAL, s, val,
-				    NULL, true, false,
-				    (struct bfd_link_hash_entry **) &myh);
+				    NULL, true, false, &bh);
 
   free (tmp_name);
 
@@ -478,6 +479,7 @@ record_thumb_to_arm_glue (link_info, h)
   asection *s;
   char *tmp_name;
   struct elf_link_hash_entry *myh;
+  struct bfd_link_hash_entry *bh;
   struct elf32_arm_link_hash_table *hash_table;
   char bind;
   bfd_vma val;
@@ -509,13 +511,14 @@ record_thumb_to_arm_glue (link_info, h)
       return;
     }
 
+  bh = NULL;
   val = hash_table->thumb_glue_size + 1;
   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
 				    tmp_name, BSF_GLOBAL, s, val,
-				    NULL, true, false,
-				    (struct bfd_link_hash_entry **) &myh);
+				    NULL, true, false, &bh);
 
   /* If we mark it 'Thumb', the disassembler will do a better job.  */
+  myh = (struct elf_link_hash_entry *) bh;
   bind = ELF_ST_BIND (myh->type);
   myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
 
@@ -532,13 +535,11 @@ record_thumb_to_arm_glue (link_info, h)
 
   sprintf (tmp_name, CHANGE_TO_ARM, name);
 
-  myh = NULL;
-
+  bh = NULL;
   val = hash_table->thumb_glue_size + 4,
   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
 				    tmp_name, BSF_LOCAL, s, val,
-				    NULL, true, false,
-				    (struct bfd_link_hash_entry **) &myh);
+				    NULL, true, false, &bh);
 
   free (tmp_name);
 
diff --git a/contrib/binutils/bfd/elf32-i386.c b/contrib/binutils/bfd/elf32-i386.c
index d52d5a7..51765ab 100644
--- a/contrib/binutils/bfd/elf32-i386.c
+++ b/contrib/binutils/bfd/elf32-i386.c
@@ -2616,36 +2616,40 @@ elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 		  BFD_ASSERT (rel->r_offset >= 1);
 		  val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
 		  BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
-		  if (val != 0xa1)
-		    {
-		      BFD_ASSERT (rel->r_offset >= 2);
-		      type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
-		    }
 		  if (val == 0xa1)
 		    {
 		      /* movl foo, %eax.  */
-		      bfd_put_8 (output_bfd, 0xb8, contents + rel->r_offset - 2);
-		    }
-		  else if (type == 0x8b)
-		    {
-		      /* movl */
-		      BFD_ASSERT ((val & 0xc7) == 0x05);
-		      bfd_put_8 (output_bfd, 0xc7,
-				 contents + rel->r_offset - 2);
-		      bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
-				 contents + rel->r_offset - 1);
+		      bfd_put_8 (output_bfd, 0xb8, contents + rel->r_offset - 1);
 		    }
-		  else if (type == 0x03)
+		  else
 		    {
-		      /* addl */
-		      BFD_ASSERT ((val & 0xc7) == 0x05);
-		      bfd_put_8 (output_bfd, 0x81,
-				 contents + rel->r_offset - 2);
-		      bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
-				 contents + rel->r_offset - 1);
+		      BFD_ASSERT (rel->r_offset >= 2);
+		      type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
+		      switch (type)
+		        {
+			case 0x8b:
+			  /* movl */
+			  BFD_ASSERT ((val & 0xc7) == 0x05);
+			  bfd_put_8 (output_bfd, 0xc7,
+				     contents + rel->r_offset - 2);
+			  bfd_put_8 (output_bfd,
+				     0xc0 | ((val >> 3) & 7),
+				     contents + rel->r_offset - 1);
+			  break;
+			case 0x03:
+			  /* addl */
+			  BFD_ASSERT ((val & 0xc7) == 0x05);
+			  bfd_put_8 (output_bfd, 0x81,
+				     contents + rel->r_offset - 2);
+			  bfd_put_8 (output_bfd,
+				     0xc0 | ((val >> 3) & 7),
+				     contents + rel->r_offset - 1);
+			  break;
+			default:
+			  BFD_FAIL ();
+			  break;
+		        }
 		    }
-		  else
-		    BFD_FAIL ();
 		  bfd_put_32 (output_bfd, -tpoff (info, relocation),
 			      contents + rel->r_offset);
 		  continue;
@@ -3384,6 +3388,4 @@ elf_i386_finish_dynamic_sections (output_bfd, info)
 #define elf_backend_relocate_section	      elf_i386_relocate_section
 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
 
-#ifndef ELF32_I386_C_INCLUDED
 #include "elf32-target.h"
-#endif
diff --git a/contrib/binutils/bfd/elf32-s390.c b/contrib/binutils/bfd/elf32-s390.c
index ed5f3f0..b7e2189 100644
--- a/contrib/binutils/bfd/elf32-s390.c
+++ b/contrib/binutils/bfd/elf32-s390.c
@@ -40,12 +40,13 @@ static boolean create_got_section
 static boolean elf_s390_create_dynamic_sections
   PARAMS((bfd *, struct bfd_link_info *));
 static void elf_s390_copy_indirect_symbol
-  PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
+  PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
+	   struct elf_link_hash_entry *));
 static boolean elf_s390_check_relocs
   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 	   const Elf_Internal_Rela *));
 static asection *elf_s390_gc_mark_hook
-  PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
+  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
 	   struct elf_link_hash_entry *, Elf_Internal_Sym *));
 static boolean elf_s390_gc_sweep_hook
   PARAMS ((bfd *, struct bfd_link_info *, asection *,
@@ -478,13 +479,13 @@ elf_s390_link_hash_table_create (abfd)
   struct elf_s390_link_hash_table *ret;
   bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
 
-  ret = (struct elf_s390_link_hash_table *) bfd_alloc (abfd, amt);
+  ret = (struct elf_s390_link_hash_table *) bfd_malloc (amt);
   if (ret == NULL)
     return NULL;
 
   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
     {
-      bfd_release (abfd, ret);
+      free (ret);
       return NULL;
     }
 
@@ -564,7 +565,8 @@ elf_s390_create_dynamic_sections (dynobj, info)
 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 
 static void
-elf_s390_copy_indirect_symbol (dir, ind)
+elf_s390_copy_indirect_symbol (bed, dir, ind)
+     struct elf_backend_data *bed;
      struct elf_link_hash_entry *dir, *ind;
 {
   struct elf_s390_link_hash_entry *edir, *eind;
@@ -606,7 +608,7 @@ elf_s390_copy_indirect_symbol (dir, ind)
       eind->dyn_relocs = NULL;
     }
 
-  _bfd_elf_link_hash_copy_indirect (dir, ind);
+  _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 }
 
 /* Look through the relocs for a section during the first phase, and
@@ -903,8 +905,8 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
    relocation.  */
 
 static asection *
-elf_s390_gc_mark_hook (abfd, info, rel, h, sym)
-     bfd *abfd;
+elf_s390_gc_mark_hook (sec, info, rel, h, sym)
+     asection *sec;
      struct bfd_link_info *info ATTRIBUTE_UNUSED;
      Elf_Internal_Rela *rel;
      struct elf_link_hash_entry *h;
@@ -934,9 +936,7 @@ elf_s390_gc_mark_hook (abfd, info, rel, h, sym)
 	}
     }
   else
-    {
-      return bfd_section_from_elf_index (abfd, sym->st_shndx);
-    }
+    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 
   return NULL;
 }
@@ -1064,7 +1064,7 @@ elf_s390_adjust_dynamic_symbol (info, h)
 
   /* If this is a function, put it in the procedure linkage table.  We
      will fill in the contents of the procedure linkage table later
-     (although we could actually do it here). */
+     (although we could actually do it here).  */
   if (h->type == STT_FUNC
       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
     {
@@ -1973,9 +1973,11 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	  break;
 	}
 
+      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
+	 because such sections are not SEC_ALLOC and thus ld.so will
+	 not process them.  */
       if (unresolved_reloc
-	  && !(info->shared
-	       && (input_section->flags & SEC_DEBUGGING) != 0
+	  && !((input_section->flags & SEC_DEBUGGING) != 0
 	       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
 	(*_bfd_error_handler)
 	  (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
diff --git a/contrib/binutils/bfd/elf32-sh.c b/contrib/binutils/bfd/elf32-sh.c
new file mode 100644
index 0000000..841c42a
--- /dev/null
+++ b/contrib/binutils/bfd/elf32-sh.c
@@ -0,0 +1,6285 @@
+/* Hitachi SH specific support for 32-bit ELF
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
+   Free Software Foundation, Inc.
+   Contributed by Ian Lance Taylor, Cygnus Support.
+
+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 "bfdlink.h"
+#include "libbfd.h"
+#include "elf-bfd.h"
+#include "elf/sh.h"
+
+static bfd_reloc_status_type sh_elf_reloc
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static bfd_reloc_status_type sh_elf_ignore_reloc
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static reloc_howto_type *sh_elf_reloc_type_lookup
+  PARAMS ((bfd *, bfd_reloc_code_real_type));
+static void sh_elf_info_to_howto
+  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
+static boolean sh_elf_set_private_flags
+  PARAMS ((bfd *, flagword));
+static boolean sh_elf_copy_private_data
+  PARAMS ((bfd *, bfd *));
+static boolean sh_elf_merge_private_data
+  PARAMS ((bfd *, bfd *));
+static boolean sh_elf_set_mach_from_flags
+  PARAMS ((bfd *));
+static boolean sh_elf_relax_section
+  PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
+static boolean sh_elf_relax_delete_bytes
+  PARAMS ((bfd *, asection *, bfd_vma, int));
+static boolean sh_elf_align_loads
+  PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, boolean *));
+static boolean sh_elf_swap_insns
+  PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
+static boolean sh_elf_relocate_section
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+	   Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
+static bfd_byte *sh_elf_get_relocated_section_contents
+  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
+	   bfd_byte *, boolean, asymbol **));
+static void sh_elf_copy_indirect_symbol
+  PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
+	   struct elf_link_hash_entry *));
+static boolean sh_elf_check_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection *,
+	   const Elf_Internal_Rela *));
+static struct bfd_hash_entry *sh_elf_link_hash_newfunc
+  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
+static struct bfd_link_hash_table *sh_elf_link_hash_table_create
+  PARAMS ((bfd *));
+static boolean sh_elf_adjust_dynamic_symbol
+  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+static boolean sh_elf_size_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static boolean sh_elf_finish_dynamic_symbol
+  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
+	   Elf_Internal_Sym *));
+static boolean sh_elf_finish_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static bfd_reloc_status_type sh_elf_reloc_loop
+  PARAMS ((int, bfd *, asection *, bfd_byte *, bfd_vma, asection *,
+	   bfd_vma, bfd_vma));
+static boolean create_got_section
+  PARAMS((bfd *, struct bfd_link_info *));
+static boolean sh_elf_create_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static asection * sh_elf_gc_mark_hook
+  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
+	   struct elf_link_hash_entry *, Elf_Internal_Sym *));
+static boolean sh_elf_gc_sweep_hook
+  PARAMS ((bfd *, struct bfd_link_info *, asection *,
+	   const Elf_Internal_Rela *));
+static boolean allocate_dynrelocs
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+static boolean readonly_dynrelocs
+  PARAMS ((struct elf_link_hash_entry *, PTR));
+static enum elf_reloc_type_class sh_elf_reloc_type_class
+  PARAMS ((const Elf_Internal_Rela *));
+#ifdef INCLUDE_SHMEDIA
+inline static void movi_shori_putval PARAMS ((bfd *, unsigned long, char *));
+#endif
+
+/* The name of the dynamic interpreter.  This is put in the .interp
+   section.  */
+
+#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
+
+static reloc_howto_type sh_elf_howto_table[] =
+{
+  /* No relocation.  */
+  HOWTO (R_SH_NONE,		/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_NONE",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 32 bit absolute relocation.  Setting partial_inplace to true and
+     src_mask to a non-zero value is similar to the COFF toolchain.  */
+  HOWTO (R_SH_DIR32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 sh_elf_reloc,		/* special_function */
+	 "R_SH_DIR32",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 32 bit PC relative relocation.  */
+  HOWTO (R_SH_REL32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_REL32",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 8 bit PC relative branch divided by 2.  */
+  HOWTO (R_SH_DIR8WPN,		/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_DIR8WPN",	/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 12 bit PC relative branch divided by 2.  */
+  HOWTO (R_SH_IND12W,		/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 12,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 sh_elf_reloc,		/* special_function */
+	 "R_SH_IND12W",		/* name */
+	 true,			/* partial_inplace */
+	 0xfff,			/* src_mask */
+	 0xfff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 8 bit unsigned PC relative divided by 4.  */
+  HOWTO (R_SH_DIR8WPL,		/* type */
+	 2,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_DIR8WPL",	/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 8 bit unsigned PC relative divided by 2.  */
+  HOWTO (R_SH_DIR8WPZ,		/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_DIR8WPZ",	/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 8 bit GBR relative.  FIXME: This only makes sense if we have some
+     special symbol for the GBR relative area, and that is not
+     implemented.  */
+  HOWTO (R_SH_DIR8BP,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_DIR8BP",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 8 bit GBR relative divided by 2.  FIXME: This only makes sense if
+     we have some special symbol for the GBR relative area, and that
+     is not implemented.  */
+  HOWTO (R_SH_DIR8W,		/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_DIR8W",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 8 bit GBR relative divided by 4.  FIXME: This only makes sense if
+     we have some special symbol for the GBR relative area, and that
+     is not implemented.  */
+  HOWTO (R_SH_DIR8L,		/* type */
+	 2,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_DIR8L",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  EMPTY_HOWTO (10),
+  EMPTY_HOWTO (11),
+  EMPTY_HOWTO (12),
+  EMPTY_HOWTO (13),
+  EMPTY_HOWTO (14),
+  EMPTY_HOWTO (15),
+  EMPTY_HOWTO (16),
+  EMPTY_HOWTO (17),
+  EMPTY_HOWTO (18),
+  EMPTY_HOWTO (19),
+  EMPTY_HOWTO (20),
+  EMPTY_HOWTO (21),
+  EMPTY_HOWTO (22),
+  EMPTY_HOWTO (23),
+  EMPTY_HOWTO (24),
+
+  /* The remaining relocs are a GNU extension used for relaxing.  The
+     final pass of the linker never needs to do anything with any of
+     these relocs.  Any required operations are handled by the
+     relaxation code.  */
+
+  /* A 16 bit switch table entry.  This is generated for an expression
+     such as ``.word L1 - L2''.  The offset holds the difference
+     between the reloc address and L2.  */
+  HOWTO (R_SH_SWITCH16,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_SWITCH16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* A 32 bit switch table entry.  This is generated for an expression
+     such as ``.long L1 - L2''.  The offset holds the difference
+     between the reloc address and L2.  */
+  HOWTO (R_SH_SWITCH32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_SWITCH32",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Indicates a .uses pseudo-op.  The compiler will generate .uses
+     pseudo-ops when it finds a function call which can be relaxed.
+     The offset field holds the PC relative offset to the instruction
+     which loads the register used in the function call.  */
+  HOWTO (R_SH_USES,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_USES",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* The assembler will generate this reloc for addresses referred to
+     by the register loads associated with USES relocs.  The offset
+     field holds the number of times the address is referenced in the
+     object file.  */
+  HOWTO (R_SH_COUNT,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_COUNT",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Indicates an alignment statement.  The offset field is the power
+     of 2 to which subsequent portions of the object file must be
+     aligned.  */
+  HOWTO (R_SH_ALIGN,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_ALIGN",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* The assembler will generate this reloc before a block of
+     instructions.  A section should be processed as assumining it
+     contains data, unless this reloc is seen.  */
+  HOWTO (R_SH_CODE,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_CODE",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* The assembler will generate this reloc after a block of
+     instructions when it sees data that is not instructions.  */
+  HOWTO (R_SH_DATA,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_DATA",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* The assembler generates this reloc for each label within a block
+     of instructions.  This permits the linker to avoid swapping
+     instructions which are the targets of branches.  */
+  HOWTO (R_SH_LABEL,		/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_LABEL",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* An 8 bit switch table entry.  This is generated for an expression
+     such as ``.word L1 - L2''.  The offset holds the difference
+     between the reloc address and L2.  */
+  HOWTO (R_SH_SWITCH8,		/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_SWITCH8",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* GNU extension to record C++ vtable hierarchy */
+  HOWTO (R_SH_GNU_VTINHERIT, /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 NULL,			/* special_function */
+	 "R_SH_GNU_VTINHERIT", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* GNU extension to record C++ vtable member usage */
+  HOWTO (R_SH_GNU_VTENTRY,     /* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 _bfd_elf_rel_vtable_reloc_fn,	/* special_function */
+	 "R_SH_GNU_VTENTRY",   /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 8 bit PC relative divided by 2 - but specified in a very odd way.  */
+  HOWTO (R_SH_LOOP_START,	/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_LOOP_START",	/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* 8 bit PC relative divided by 2 - but specified in a very odd way.  */
+  HOWTO (R_SH_LOOP_END,		/* type */
+	 1,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_LOOP_END",	/* name */
+	 true,			/* partial_inplace */
+	 0xff,			/* src_mask */
+	 0xff,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  EMPTY_HOWTO (38),
+  EMPTY_HOWTO (39),
+  EMPTY_HOWTO (40),
+  EMPTY_HOWTO (41),
+  EMPTY_HOWTO (42),
+  EMPTY_HOWTO (43),
+  EMPTY_HOWTO (44),
+
+#ifdef INCLUDE_SHMEDIA
+  /* Used in SHLLI.L and SHLRI.L.  */
+  HOWTO (R_SH_DIR5U,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 5,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_DIR5U",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in SHARI, SHLLI et al.  */
+  HOWTO (R_SH_DIR6U,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 6,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_DIR6U",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in BxxI, LDHI.L et al.  */
+  HOWTO (R_SH_DIR6S,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 6,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_DIR6S",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xfc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in ADDI, ANDI et al.  */
+  HOWTO (R_SH_DIR10S,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 10,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_DIR10S",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in LD.UW, ST.W et al.	 */
+  HOWTO (R_SH_DIR10SW,	/* type */
+	 1,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 11,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_DIR10SW",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in LD.L, FLD.S et al.	 */
+  HOWTO (R_SH_DIR10SL,	/* type */
+	 2,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 12,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_DIR10SL",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in FLD.D, FST.P et al.  */
+  HOWTO (R_SH_DIR10SQ,	/* type */
+	 3,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 13,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_DIR10SQ",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+#else
+  EMPTY_HOWTO (45),
+  EMPTY_HOWTO (46),
+  EMPTY_HOWTO (47),
+  EMPTY_HOWTO (48),
+  EMPTY_HOWTO (49),
+  EMPTY_HOWTO (50),
+  EMPTY_HOWTO (51),
+#endif
+
+  EMPTY_HOWTO (52),
+  EMPTY_HOWTO (53),
+  EMPTY_HOWTO (54),
+  EMPTY_HOWTO (55),
+  EMPTY_HOWTO (56),
+  EMPTY_HOWTO (57),
+  EMPTY_HOWTO (58),
+  EMPTY_HOWTO (59),
+  EMPTY_HOWTO (60),
+  EMPTY_HOWTO (61),
+  EMPTY_HOWTO (62),
+  EMPTY_HOWTO (63),
+  EMPTY_HOWTO (64),
+  EMPTY_HOWTO (65),
+  EMPTY_HOWTO (66),
+  EMPTY_HOWTO (67),
+  EMPTY_HOWTO (68),
+  EMPTY_HOWTO (69),
+  EMPTY_HOWTO (70),
+  EMPTY_HOWTO (71),
+  EMPTY_HOWTO (72),
+  EMPTY_HOWTO (73),
+  EMPTY_HOWTO (74),
+  EMPTY_HOWTO (75),
+  EMPTY_HOWTO (76),
+  EMPTY_HOWTO (77),
+  EMPTY_HOWTO (78),
+  EMPTY_HOWTO (79),
+  EMPTY_HOWTO (80),
+  EMPTY_HOWTO (81),
+  EMPTY_HOWTO (82),
+  EMPTY_HOWTO (83),
+  EMPTY_HOWTO (84),
+  EMPTY_HOWTO (85),
+  EMPTY_HOWTO (86),
+  EMPTY_HOWTO (87),
+  EMPTY_HOWTO (88),
+  EMPTY_HOWTO (89),
+  EMPTY_HOWTO (90),
+  EMPTY_HOWTO (91),
+  EMPTY_HOWTO (92),
+  EMPTY_HOWTO (93),
+  EMPTY_HOWTO (94),
+  EMPTY_HOWTO (95),
+  EMPTY_HOWTO (96),
+  EMPTY_HOWTO (97),
+  EMPTY_HOWTO (98),
+  EMPTY_HOWTO (99),
+  EMPTY_HOWTO (100),
+  EMPTY_HOWTO (101),
+  EMPTY_HOWTO (102),
+  EMPTY_HOWTO (103),
+  EMPTY_HOWTO (104),
+  EMPTY_HOWTO (105),
+  EMPTY_HOWTO (106),
+  EMPTY_HOWTO (107),
+  EMPTY_HOWTO (108),
+  EMPTY_HOWTO (109),
+  EMPTY_HOWTO (110),
+  EMPTY_HOWTO (111),
+  EMPTY_HOWTO (112),
+  EMPTY_HOWTO (113),
+  EMPTY_HOWTO (114),
+  EMPTY_HOWTO (115),
+  EMPTY_HOWTO (116),
+  EMPTY_HOWTO (117),
+  EMPTY_HOWTO (118),
+  EMPTY_HOWTO (119),
+  EMPTY_HOWTO (120),
+  EMPTY_HOWTO (121),
+  EMPTY_HOWTO (122),
+  EMPTY_HOWTO (123),
+  EMPTY_HOWTO (124),
+  EMPTY_HOWTO (125),
+  EMPTY_HOWTO (126),
+  EMPTY_HOWTO (127),
+  EMPTY_HOWTO (128),
+  EMPTY_HOWTO (129),
+  EMPTY_HOWTO (130),
+  EMPTY_HOWTO (131),
+  EMPTY_HOWTO (132),
+  EMPTY_HOWTO (133),
+  EMPTY_HOWTO (134),
+  EMPTY_HOWTO (135),
+  EMPTY_HOWTO (136),
+  EMPTY_HOWTO (137),
+  EMPTY_HOWTO (138),
+  EMPTY_HOWTO (139),
+  EMPTY_HOWTO (140),
+  EMPTY_HOWTO (141),
+  EMPTY_HOWTO (142),
+  EMPTY_HOWTO (143),
+  EMPTY_HOWTO (144),
+  EMPTY_HOWTO (145),
+  EMPTY_HOWTO (146),
+  EMPTY_HOWTO (147),
+  EMPTY_HOWTO (148),
+  EMPTY_HOWTO (149),
+  EMPTY_HOWTO (150),
+  EMPTY_HOWTO (151),
+  EMPTY_HOWTO (152),
+  EMPTY_HOWTO (153),
+  EMPTY_HOWTO (154),
+  EMPTY_HOWTO (155),
+  EMPTY_HOWTO (156),
+  EMPTY_HOWTO (157),
+  EMPTY_HOWTO (158),
+  EMPTY_HOWTO (159),
+
+  HOWTO (R_SH_GOT32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_GOT32",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_PLT32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_PLT32",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  HOWTO (R_SH_COPY,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_COPY",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_GLOB_DAT,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_GLOB_DAT",	/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_JMP_SLOT,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_JMP_SLOT",	/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_RELATIVE,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_RELATIVE",	/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_GOTOFF,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_GOTOFF",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_GOTPC,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_GOTPC",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  HOWTO (R_SH_GOTPLT32,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* */
+	 "R_SH_GOTPLT32",	/* name */
+	 false,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+#ifdef INCLUDE_SHMEDIA
+  /* Used in MOVI and SHORI (x & 65536).  */
+  HOWTO (R_SH_GOT_LOW16,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOT_LOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
+  HOWTO (R_SH_GOT_MEDLOW16,	/* type */
+	 16,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOT_MEDLOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
+  HOWTO (R_SH_GOT_MEDHI16,	/* type */
+	 32,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOT_MEDHI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
+  HOWTO (R_SH_GOT_HI16,		/* type */
+	 48,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOT_HI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI (x & 65536).  */
+  HOWTO (R_SH_GOTPLT_LOW16,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPLT_LOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
+  HOWTO (R_SH_GOTPLT_MEDLOW16,	/* type */
+	 16,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPLT_MEDLOW16", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
+  HOWTO (R_SH_GOTPLT_MEDHI16,	/* type */
+	 32,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPLT_MEDHI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
+  HOWTO (R_SH_GOTPLT_HI16,	/* type */
+	 48,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPLT_HI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI (x & 65536).  */
+  HOWTO (R_SH_PLT_LOW16,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_PLT_LOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
+  HOWTO (R_SH_PLT_MEDLOW16,	/* type */
+	 16,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_PLT_MEDLOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
+  HOWTO (R_SH_PLT_MEDHI16,	/* type */
+	 32,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_PLT_MEDHI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
+  HOWTO (R_SH_PLT_HI16,		/* type */
+	 48,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_PLT_HI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI (x & 65536).  */
+  HOWTO (R_SH_GOTOFF_LOW16,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTOFF_LOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
+  HOWTO (R_SH_GOTOFF_MEDLOW16,	/* type */
+	 16,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTOFF_MEDLOW16", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
+  HOWTO (R_SH_GOTOFF_MEDHI16,	/* type */
+	 32,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTOFF_MEDHI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
+  HOWTO (R_SH_GOTOFF_HI16,	/* type */
+	 48,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTOFF_HI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI (x & 65536).  */
+  HOWTO (R_SH_GOTPC_LOW16,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPC_LOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
+  HOWTO (R_SH_GOTPC_MEDLOW16,	/* type */
+	 16,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPC_MEDLOW16", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
+  HOWTO (R_SH_GOTPC_MEDHI16,	/* type */
+	 32,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPC_MEDHI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
+  HOWTO (R_SH_GOTPC_HI16,	/* type */
+	 48,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPC_HI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in LD.L, FLD.S et al.	 */
+  HOWTO (R_SH_GOT10BY4,		/* type */
+	 2,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 12,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOT10BY4",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in LD.L, FLD.S et al.	 */
+  HOWTO (R_SH_GOTPLT10BY4,	/* type */
+	 2,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 12,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPLT10BY4",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in FLD.D, FST.P et al.  */
+  HOWTO (R_SH_GOT10BY8,		/* type */
+	 3,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 13,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOT10BY8",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in FLD.D, FST.P et al.  */
+  HOWTO (R_SH_GOTPLT10BY8,	/* type */
+	 3,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 13,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GOTPLT10BY8",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_COPY64,		/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_COPY64",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 ((bfd_vma) 0) - 1,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_GLOB_DAT64,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_GLOB_DAT64",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 ((bfd_vma) 0) - 1,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_JMP_SLOT64,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_JMP_SLOT64",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 ((bfd_vma) 0) - 1,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO (R_SH_RELATIVE64,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_RELATIVE64",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 ((bfd_vma) 0) - 1,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  EMPTY_HOWTO (197),
+  EMPTY_HOWTO (198),
+  EMPTY_HOWTO (199),
+  EMPTY_HOWTO (200),
+  EMPTY_HOWTO (201),
+  EMPTY_HOWTO (202),
+  EMPTY_HOWTO (203),
+  EMPTY_HOWTO (204),
+  EMPTY_HOWTO (205),
+  EMPTY_HOWTO (206),
+  EMPTY_HOWTO (207),
+  EMPTY_HOWTO (208),
+  EMPTY_HOWTO (209),
+  EMPTY_HOWTO (210),
+  EMPTY_HOWTO (211),
+  EMPTY_HOWTO (212),
+  EMPTY_HOWTO (213),
+  EMPTY_HOWTO (214),
+  EMPTY_HOWTO (215),
+  EMPTY_HOWTO (216),
+  EMPTY_HOWTO (217),
+  EMPTY_HOWTO (218),
+  EMPTY_HOWTO (219),
+  EMPTY_HOWTO (220),
+  EMPTY_HOWTO (221),
+  EMPTY_HOWTO (222),
+  EMPTY_HOWTO (223),
+  EMPTY_HOWTO (224),
+  EMPTY_HOWTO (225),
+  EMPTY_HOWTO (226),
+  EMPTY_HOWTO (227),
+  EMPTY_HOWTO (228),
+  EMPTY_HOWTO (229),
+  EMPTY_HOWTO (230),
+  EMPTY_HOWTO (231),
+  EMPTY_HOWTO (232),
+  EMPTY_HOWTO (233),
+  EMPTY_HOWTO (234),
+  EMPTY_HOWTO (235),
+  EMPTY_HOWTO (236),
+  EMPTY_HOWTO (237),
+  EMPTY_HOWTO (238),
+  EMPTY_HOWTO (239),
+  EMPTY_HOWTO (240),
+  EMPTY_HOWTO (241),
+
+  /* Relocations for SHmedia code.  None of these are partial_inplace or
+     use the field being relocated (except R_SH_PT_16).  */
+
+  /* The assembler will generate this reloc before a block of SHmedia
+     instructions.  A section should be processed as assuming it contains
+     data, unless this reloc is seen.  Note that a block of SHcompact
+     instructions are instead preceded by R_SH_CODE.
+     This is currently not implemented, but should be used for SHmedia
+     linker relaxation.  */
+  HOWTO (R_SH_SHMEDIA_CODE,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 sh_elf_ignore_reloc,	/* special_function */
+	 "R_SH_SHMEDIA_CODE",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* The assembler will generate this reloc at a PTA or PTB instruction,
+     and the linker checks the right type of target, or changes a PTA to a
+     PTB, if the original insn was PT.  */
+  HOWTO (R_SH_PT_16,		/* type */
+	 2,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 18,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_PT_16",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in unexpanded MOVI.  */
+  HOWTO (R_SH_IMMS16,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMMS16",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in SHORI.  */
+  HOWTO (R_SH_IMMU16,		/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_unsigned, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMMU16",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI (x & 65536).  */
+  HOWTO (R_SH_IMM_LOW16,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMM_LOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x - $) & 65536).  */
+  HOWTO (R_SH_IMM_LOW16_PCREL,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMM_LOW16_PCREL", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
+  HOWTO (R_SH_IMM_MEDLOW16,	/* type */
+	 16,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMM_MEDLOW16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI (((x - $) >> 16) & 65536).  */
+  HOWTO (R_SH_IMM_MEDLOW16_PCREL, /* type */
+	 16,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMM_MEDLOW16_PCREL", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
+  HOWTO (R_SH_IMM_MEDHI16,	/* type */
+	 32,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMM_MEDHI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI (((x - $) >> 32) & 65536).  */
+  HOWTO (R_SH_IMM_MEDHI16_PCREL, /* type */
+	 32,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMM_MEDHI16_PCREL", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
+  HOWTO (R_SH_IMM_HI16,		/* type */
+	 48,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMM_HI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Used in MOVI and SHORI (((x - $) >> 48) & 65536).  */
+  HOWTO (R_SH_IMM_HI16_PCREL,	/* type */
+	 48,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_IMM_HI16_PCREL", /* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0x3fffc00,		/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* For the .uaquad pseudo.  */
+  HOWTO (R_SH_64,		/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_64",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 ((bfd_vma) 0) - 1,	/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* For the .uaquad pseudo, (x - $).  */
+  HOWTO (R_SH_64_PCREL,		/* type */
+	 48,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 10,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 bfd_elf_generic_reloc,	/* special_function */
+	 "R_SH_64_PCREL",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 ((bfd_vma) 0) - 1,	/* dst_mask */
+	 true),			/* pcrel_offset */
+
+#endif
+};
+
+static bfd_reloc_status_type
+sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr,
+		   symbol_section, start, end)
+     int r_type ATTRIBUTE_UNUSED;
+     bfd *input_bfd;
+     asection *input_section;
+     bfd_byte *contents;
+     bfd_vma addr;
+     asection *symbol_section;
+     bfd_vma start, end;
+{
+  static bfd_vma last_addr;
+  static asection *last_symbol_section;
+  bfd_byte *start_ptr, *ptr, *last_ptr;
+  int diff, cum_diff;
+  bfd_signed_vma x;
+  int insn;
+
+  /* Sanity check the address.  */
+  if (addr > input_section->_raw_size)
+    return bfd_reloc_outofrange;
+
+  /* We require the start and end relocations to be processed consecutively -
+     although we allow then to be processed forwards or backwards.  */
+  if (! last_addr)
+    {
+      last_addr = addr;
+      last_symbol_section = symbol_section;
+      return bfd_reloc_ok;
+    }
+  if (last_addr != addr)
+    abort ();
+  last_addr = 0;
+
+  if (! symbol_section || last_symbol_section != symbol_section || end < start)
+    return bfd_reloc_outofrange;
+
+  /* Get the symbol_section contents.  */
+  if (symbol_section != input_section)
+    {
+      if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
+	contents = elf_section_data (symbol_section)->this_hdr.contents;
+      else
+	{
+	  contents = (bfd_byte *) bfd_malloc (symbol_section->_raw_size);
+	  if (contents == NULL)
+	    return bfd_reloc_outofrange;
+	  if (! bfd_get_section_contents (input_bfd, symbol_section, contents,
+					  (file_ptr) 0,
+					  symbol_section->_raw_size))
+	    {
+	      free (contents);
+	      return bfd_reloc_outofrange;
+	    }
+	}
+    }
+#define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
+  start_ptr = contents + start;
+  for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
+    {
+      for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
+	ptr -= 2;
+      ptr += 2;
+      diff = (last_ptr - ptr) >> 1;
+      cum_diff += diff & 1;
+      cum_diff += diff;
+    }
+  /* Calculate the start / end values to load into rs / re minus four -
+     so that will cancel out the four we would otherwise have to add to
+     addr to get the value to subtract in order to get relative addressing.  */
+  if (cum_diff >= 0)
+    {
+      start -= 4;
+      end = (ptr + cum_diff * 2) - contents;
+    }
+  else
+    {
+      bfd_vma start0 = start - 4;
+
+      while (start0 && IS_PPI (contents + start0))
+	start0 -= 2;
+      start0 = start - 2 - ((start - start0) & 2);
+      start = start0 - cum_diff - 2;
+      end = start0;
+    }
+
+  if (contents != NULL
+      && elf_section_data (symbol_section)->this_hdr.contents != contents)
+    free (contents);
+
+  insn = bfd_get_16 (input_bfd, contents + addr);
+
+  x = (insn & 0x200 ? end : start) - addr;
+  if (input_section != symbol_section)
+    x += ((symbol_section->output_section->vma + symbol_section->output_offset)
+	  - (input_section->output_section->vma
+	     + input_section->output_offset));
+  x >>= 1;
+  if (x < -128 || x > 127)
+    return bfd_reloc_overflow;
+
+  x = (insn & ~0xff) | (x & 0xff);
+  bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr);
+
+  return bfd_reloc_ok;
+}
+
+/* This function is used for normal relocs.  This used to be like the COFF
+   function, and is almost certainly incorrect for other ELF targets.  */
+
+static bfd_reloc_status_type
+sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
+	      error_message)
+     bfd *abfd;
+     arelent *reloc_entry;
+     asymbol *symbol_in;
+     PTR data;
+     asection *input_section;
+     bfd *output_bfd;
+     char **error_message ATTRIBUTE_UNUSED;
+{
+  unsigned long insn;
+  bfd_vma sym_value;
+  enum elf_sh_reloc_type r_type;
+  bfd_vma addr = reloc_entry->address;
+  bfd_byte *hit_data = addr + (bfd_byte *) data;
+
+  r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
+
+  if (output_bfd != NULL)
+    {
+      /* Partial linking--do nothing.  */
+      reloc_entry->address += input_section->output_offset;
+      return bfd_reloc_ok;
+    }
+
+  /* Almost all relocs have to do with relaxing.  If any work must be
+     done for them, it has been done in sh_relax_section.  */
+  if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
+    return bfd_reloc_ok;
+
+  if (symbol_in != NULL
+      && bfd_is_und_section (symbol_in->section))
+    return bfd_reloc_undefined;
+
+  if (bfd_is_com_section (symbol_in->section))
+    sym_value = 0;
+  else
+    sym_value = (symbol_in->value +
+		 symbol_in->section->output_section->vma +
+		 symbol_in->section->output_offset);
+
+  switch (r_type)
+    {
+    case R_SH_DIR32:
+      insn = bfd_get_32 (abfd, hit_data);
+      insn += sym_value + reloc_entry->addend;
+      bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
+      break;
+    case R_SH_IND12W:
+      insn = bfd_get_16 (abfd, hit_data);
+      sym_value += reloc_entry->addend;
+      sym_value -= (input_section->output_section->vma
+		    + input_section->output_offset
+		    + addr
+		    + 4);
+      sym_value += (insn & 0xfff) << 1;
+      if (insn & 0x800)
+	sym_value -= 0x1000;
+      insn = (insn & 0xf000) | (sym_value & 0xfff);
+      bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
+      if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
+	return bfd_reloc_overflow;
+      break;
+    default:
+      abort ();
+      break;
+    }
+
+  return bfd_reloc_ok;
+}
+
+/* This function is used for relocs which are only used for relaxing,
+   which the linker should otherwise ignore.  */
+
+static bfd_reloc_status_type
+sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
+		     output_bfd, error_message)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     arelent *reloc_entry;
+     asymbol *symbol ATTRIBUTE_UNUSED;
+     PTR data ATTRIBUTE_UNUSED;
+     asection *input_section;
+     bfd *output_bfd;
+     char **error_message ATTRIBUTE_UNUSED;
+{
+  if (output_bfd != NULL)
+    reloc_entry->address += input_section->output_offset;
+  return bfd_reloc_ok;
+}
+
+/* This structure is used to map BFD reloc codes to SH ELF relocs.  */
+
+struct elf_reloc_map
+{
+  bfd_reloc_code_real_type bfd_reloc_val;
+  unsigned char elf_reloc_val;
+};
+
+/* An array mapping BFD reloc codes to SH ELF relocs.  */
+
+static const struct elf_reloc_map sh_reloc_map[] =
+{
+  { BFD_RELOC_NONE, R_SH_NONE },
+  { BFD_RELOC_32, R_SH_DIR32 },
+  { BFD_RELOC_CTOR, R_SH_DIR32 },
+  { BFD_RELOC_32_PCREL, R_SH_REL32 },
+  { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
+  { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
+  { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
+  { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
+  { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
+  { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
+  { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
+  { BFD_RELOC_SH_USES, R_SH_USES },
+  { BFD_RELOC_SH_COUNT, R_SH_COUNT },
+  { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
+  { BFD_RELOC_SH_CODE, R_SH_CODE },
+  { BFD_RELOC_SH_DATA, R_SH_DATA },
+  { BFD_RELOC_SH_LABEL, R_SH_LABEL },
+  { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
+  { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
+  { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
+  { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
+  { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
+  { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
+  { BFD_RELOC_SH_COPY, R_SH_COPY },
+  { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
+  { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
+  { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
+  { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
+  { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
+  { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 },
+#ifdef INCLUDE_SHMEDIA
+  { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
+  { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
+  { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
+  { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
+  { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
+  { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
+  { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
+  { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
+  { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
+  { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
+  { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
+  { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
+  { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
+  { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
+  { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
+  { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
+  { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
+  { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
+  { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
+  { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
+  { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
+  { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
+  { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
+  { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
+  { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
+  { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
+  { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
+  { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
+  { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
+  { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
+  { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
+  { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
+  { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
+  { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
+  { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
+  { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
+  { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
+  { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
+  { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
+  { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
+  { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
+  { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
+  { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
+  { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
+  { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
+  { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
+  { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
+  { BFD_RELOC_64, R_SH_64 },
+  { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
+#endif /* not INCLUDE_SHMEDIA */
+};
+
+/* Given a BFD reloc code, return the howto structure for the
+   corresponding SH ELf reloc.  */
+
+static reloc_howto_type *
+sh_elf_reloc_type_lookup (abfd, code)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     bfd_reloc_code_real_type code;
+{
+  unsigned int i;
+
+  for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
+    {
+      if (sh_reloc_map[i].bfd_reloc_val == code)
+	return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
+    }
+
+  return NULL;
+}
+
+/* Given an ELF reloc, fill in the howto field of a relent.  */
+
+static void
+sh_elf_info_to_howto (abfd, cache_ptr, dst)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     arelent *cache_ptr;
+     Elf_Internal_Rela *dst;
+{
+  unsigned int r;
+
+  r = ELF32_R_TYPE (dst->r_info);
+
+  BFD_ASSERT (r < (unsigned int) R_SH_max);
+  BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
+  BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2);
+  BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_LAST_INVALID_RELOC_3);
+  BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
+
+  cache_ptr->howto = &sh_elf_howto_table[r];
+}
+
+/* This function handles relaxing for SH ELF.  See the corresponding
+   function in coff-sh.c for a description of what this does.  FIXME:
+   There is a lot of duplication here between this code and the COFF
+   specific code.  The format of relocs and symbols is wound deeply
+   into this code, but it would still be better if the duplication
+   could be eliminated somehow.  Note in particular that although both
+   functions use symbols like R_SH_CODE, those symbols have different
+   values; in coff-sh.c they come from include/coff/sh.h, whereas here
+   they come from enum elf_sh_reloc_type in include/elf/sh.h.  */
+
+static boolean
+sh_elf_relax_section (abfd, sec, link_info, again)
+     bfd *abfd;
+     asection *sec;
+     struct bfd_link_info *link_info;
+     boolean *again;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  Elf_Internal_Rela *internal_relocs;
+  boolean have_code;
+  Elf_Internal_Rela *irel, *irelend;
+  bfd_byte *contents = NULL;
+  Elf_Internal_Sym *isymbuf = NULL;
+
+  *again = false;
+
+  if (link_info->relocateable
+      || (sec->flags & SEC_RELOC) == 0
+      || sec->reloc_count == 0)
+    return true;
+
+#ifdef INCLUDE_SHMEDIA
+  if (elf_section_data (sec)->this_hdr.sh_flags
+      & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
+    {
+      return true;
+    }
+#endif
+
+  /* If this is the first time we have been called for this section,
+     initialize the cooked size.  */
+  if (sec->_cooked_size == 0)
+    sec->_cooked_size = sec->_raw_size;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+
+  internal_relocs = (_bfd_elf32_link_read_relocs
+		     (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
+		      link_info->keep_memory));
+  if (internal_relocs == NULL)
+    goto error_return;
+
+  have_code = false;
+
+  irelend = internal_relocs + sec->reloc_count;
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      bfd_vma laddr, paddr, symval;
+      unsigned short insn;
+      Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
+      bfd_signed_vma foff;
+
+      if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
+	have_code = true;
+
+      if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
+	continue;
+
+      /* Get the section contents.  */
+      if (contents == NULL)
+	{
+	  if (elf_section_data (sec)->this_hdr.contents != NULL)
+	    contents = elf_section_data (sec)->this_hdr.contents;
+	  else
+	    {
+	      contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
+	      if (contents == NULL)
+		goto error_return;
+
+	      if (! bfd_get_section_contents (abfd, sec, contents,
+					      (file_ptr) 0, sec->_raw_size))
+		goto error_return;
+	    }
+	}
+
+      /* The r_addend field of the R_SH_USES reloc will point us to
+	 the register load.  The 4 is because the r_addend field is
+	 computed as though it were a jump offset, which are based
+	 from 4 bytes after the jump instruction.  */
+      laddr = irel->r_offset + 4 + irel->r_addend;
+      if (laddr >= sec->_raw_size)
+	{
+	  (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
+				 bfd_archive_filename (abfd),
+				 (unsigned long) irel->r_offset);
+	  continue;
+	}
+      insn = bfd_get_16 (abfd, contents + laddr);
+
+      /* If the instruction is not mov.l NN,rN, we don't know what to
+	 do.  */
+      if ((insn & 0xf000) != 0xd000)
+	{
+	  ((*_bfd_error_handler)
+	   (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
+	    bfd_archive_filename (abfd), (unsigned long) irel->r_offset, insn));
+	  continue;
+	}
+
+      /* Get the address from which the register is being loaded.  The
+	 displacement in the mov.l instruction is quadrupled.  It is a
+	 displacement from four bytes after the movl instruction, but,
+	 before adding in the PC address, two least significant bits
+	 of the PC are cleared.  We assume that the section is aligned
+	 on a four byte boundary.  */
+      paddr = insn & 0xff;
+      paddr *= 4;
+      paddr += (laddr + 4) &~ (bfd_vma) 3;
+      if (paddr >= sec->_raw_size)
+	{
+	  ((*_bfd_error_handler)
+	   (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
+	    bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
+	  continue;
+	}
+
+      /* Get the reloc for the address from which the register is
+	 being loaded.  This reloc will tell us which function is
+	 actually being called.  */
+      for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
+	if (irelfn->r_offset == paddr
+	    && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
+	  break;
+      if (irelfn >= irelend)
+	{
+	  ((*_bfd_error_handler)
+	   (_("%s: 0x%lx: warning: could not find expected reloc"),
+	    bfd_archive_filename (abfd), (unsigned long) paddr));
+	  continue;
+	}
+
+      /* Read this BFD's symbols if we haven't done so already.  */
+      if (isymbuf == NULL && symtab_hdr->sh_info != 0)
+	{
+	  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
+	  if (isymbuf == NULL)
+	    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
+					    symtab_hdr->sh_info, 0,
+					    NULL, NULL, NULL);
+	  if (isymbuf == NULL)
+	    goto error_return;
+	}
+
+      /* Get the value of the symbol referred to by the reloc.  */
+      if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
+	{
+	  /* A local symbol.  */
+	  Elf_Internal_Sym *isym;
+
+	  isym = isymbuf + ELF32_R_SYM (irelfn->r_info);
+	  if (isym->st_shndx
+	      != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
+	    {
+	      ((*_bfd_error_handler)
+	       (_("%s: 0x%lx: warning: symbol in unexpected section"),
+		bfd_archive_filename (abfd), (unsigned long) paddr));
+	      continue;
+	    }
+
+	  symval = (isym->st_value
+		    + sec->output_section->vma
+		    + sec->output_offset);
+	}
+      else
+	{
+	  unsigned long indx;
+	  struct elf_link_hash_entry *h;
+
+	  indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
+	  h = elf_sym_hashes (abfd)[indx];
+	  BFD_ASSERT (h != NULL);
+	  if (h->root.type != bfd_link_hash_defined
+	      && h->root.type != bfd_link_hash_defweak)
+	    {
+	      /* This appears to be a reference to an undefined
+		 symbol.  Just ignore it--it will be caught by the
+		 regular reloc processing.  */
+	      continue;
+	    }
+
+	  symval = (h->root.u.def.value
+		    + h->root.u.def.section->output_section->vma
+		    + h->root.u.def.section->output_offset);
+	}
+
+      symval += bfd_get_32 (abfd, contents + paddr);
+
+      /* See if this function call can be shortened.  */
+      foff = (symval
+	      - (irel->r_offset
+		 + sec->output_section->vma
+		 + sec->output_offset
+		 + 4));
+      if (foff < -0x1000 || foff >= 0x1000)
+	{
+	  /* After all that work, we can't shorten this function call.  */
+	  continue;
+	}
+
+      /* Shorten the function call.  */
+
+      /* For simplicity of coding, we are going to modify the section
+	 contents, the section relocs, and the BFD symbol table.  We
+	 must tell the rest of the code not to free up this
+	 information.  It would be possible to instead create a table
+	 of changes which have to be made, as is done in coff-mips.c;
+	 that would be more work, but would require less memory when
+	 the linker is run.  */
+
+      elf_section_data (sec)->relocs = internal_relocs;
+      elf_section_data (sec)->this_hdr.contents = contents;
+      symtab_hdr->contents = (unsigned char *) isymbuf;
+
+      /* Replace the jsr with a bsr.  */
+
+      /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
+	 replace the jsr with a bsr.  */
+      irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
+      if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
+	{
+	  /* If this needs to be changed because of future relaxing,
+	     it will be handled here like other internal IND12W
+	     relocs.  */
+	  bfd_put_16 (abfd,
+		      (bfd_vma) 0xb000 | ((foff >> 1) & 0xfff),
+		      contents + irel->r_offset);
+	}
+      else
+	{
+	  /* We can't fully resolve this yet, because the external
+	     symbol value may be changed by future relaxing.  We let
+	     the final link phase handle it.  */
+	  bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
+	}
+
+      /* See if there is another R_SH_USES reloc referring to the same
+	 register load.  */
+      for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
+	if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
+	    && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
+	  break;
+      if (irelscan < irelend)
+	{
+	  /* Some other function call depends upon this register load,
+	     and we have not yet converted that function call.
+	     Indeed, we may never be able to convert it.  There is
+	     nothing else we can do at this point.  */
+	  continue;
+	}
+
+      /* Look for a R_SH_COUNT reloc on the location where the
+	 function address is stored.  Do this before deleting any
+	 bytes, to avoid confusion about the address.  */
+      for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
+	if (irelcount->r_offset == paddr
+	    && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
+	  break;
+
+      /* Delete the register load.  */
+      if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
+	goto error_return;
+
+      /* That will change things, so, just in case it permits some
+	 other function call to come within range, we should relax
+	 again.  Note that this is not required, and it may be slow.  */
+      *again = true;
+
+      /* Now check whether we got a COUNT reloc.  */
+      if (irelcount >= irelend)
+	{
+	  ((*_bfd_error_handler)
+	   (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
+	    bfd_archive_filename (abfd), (unsigned long) paddr));
+	  continue;
+	}
+
+      /* The number of uses is stored in the r_addend field.  We've
+	 just deleted one.  */
+      if (irelcount->r_addend == 0)
+	{
+	  ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
+				  bfd_archive_filename (abfd),
+				  (unsigned long) paddr));
+	  continue;
+	}
+
+      --irelcount->r_addend;
+
+      /* If there are no more uses, we can delete the address.  Reload
+	 the address from irelfn, in case it was changed by the
+	 previous call to sh_elf_relax_delete_bytes.  */
+      if (irelcount->r_addend == 0)
+	{
+	  if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
+	    goto error_return;
+	}
+
+      /* We've done all we can with that function call.  */
+    }
+
+  /* Look for load and store instructions that we can align on four
+     byte boundaries.  */
+  if (have_code)
+    {
+      boolean swapped;
+
+      /* Get the section contents.  */
+      if (contents == NULL)
+	{
+	  if (elf_section_data (sec)->this_hdr.contents != NULL)
+	    contents = elf_section_data (sec)->this_hdr.contents;
+	  else
+	    {
+	      contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
+	      if (contents == NULL)
+		goto error_return;
+
+	      if (! bfd_get_section_contents (abfd, sec, contents,
+					      (file_ptr) 0, sec->_raw_size))
+		goto error_return;
+	    }
+	}
+
+      if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
+				&swapped))
+	goto error_return;
+
+      if (swapped)
+	{
+	  elf_section_data (sec)->relocs = internal_relocs;
+	  elf_section_data (sec)->this_hdr.contents = contents;
+	  symtab_hdr->contents = (unsigned char *) isymbuf;
+	}
+    }
+
+  if (isymbuf != NULL
+      && symtab_hdr->contents != (unsigned char *) isymbuf)
+    {
+      if (! link_info->keep_memory)
+	free (isymbuf);
+      else
+	{
+	  /* Cache the symbols for elf_link_input_bfd.  */
+	  symtab_hdr->contents = (unsigned char *) isymbuf;
+	}
+    }
+
+  if (contents != NULL
+      && elf_section_data (sec)->this_hdr.contents != contents)
+    {
+      if (! link_info->keep_memory)
+	free (contents);
+      else
+	{
+	  /* Cache the section contents for elf_link_input_bfd.  */
+	  elf_section_data (sec)->this_hdr.contents = contents;
+	}
+    }
+
+  if (internal_relocs != NULL
+      && elf_section_data (sec)->relocs != internal_relocs)
+    free (internal_relocs);
+
+  return true;
+
+ error_return:
+  if (isymbuf != NULL
+      && symtab_hdr->contents != (unsigned char *) isymbuf)
+    free (isymbuf);
+  if (contents != NULL
+      && elf_section_data (sec)->this_hdr.contents != contents)
+    free (contents);
+  if (internal_relocs != NULL
+      && elf_section_data (sec)->relocs != internal_relocs)
+    free (internal_relocs);
+
+  return false;
+}
+
+/* Delete some bytes from a section while relaxing.  FIXME: There is a
+   lot of duplication between this function and sh_relax_delete_bytes
+   in coff-sh.c.  */
+
+static boolean
+sh_elf_relax_delete_bytes (abfd, sec, addr, count)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma addr;
+     int count;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  unsigned int sec_shndx;
+  bfd_byte *contents;
+  Elf_Internal_Rela *irel, *irelend;
+  Elf_Internal_Rela *irelalign;
+  bfd_vma toaddr;
+  Elf_Internal_Sym *isymbuf, *isym, *isymend;
+  struct elf_link_hash_entry **sym_hashes;
+  struct elf_link_hash_entry **end_hashes;
+  unsigned int symcount;
+  asection *o;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
+
+  sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
+
+  contents = elf_section_data (sec)->this_hdr.contents;
+
+  /* The deletion must stop at the next ALIGN reloc for an aligment
+     power larger than the number of bytes we are deleting.  */
+
+  irelalign = NULL;
+  toaddr = sec->_cooked_size;
+
+  irel = elf_section_data (sec)->relocs;
+  irelend = irel + sec->reloc_count;
+  for (; irel < irelend; irel++)
+    {
+      if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
+	  && irel->r_offset > addr
+	  && count < (1 << irel->r_addend))
+	{
+	  irelalign = irel;
+	  toaddr = irel->r_offset;
+	  break;
+	}
+    }
+
+  /* Actually delete the bytes.  */
+  memmove (contents + addr, contents + addr + count,
+	   (size_t) (toaddr - addr - count));
+  if (irelalign == NULL)
+    sec->_cooked_size -= count;
+  else
+    {
+      int i;
+
+#define NOP_OPCODE (0x0009)
+
+      BFD_ASSERT ((count & 1) == 0);
+      for (i = 0; i < count; i += 2)
+	bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
+    }
+
+  /* Adjust all the relocs.  */
+  for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
+    {
+      bfd_vma nraddr, stop;
+      bfd_vma start = 0;
+      int insn = 0;
+      int off, adjust, oinsn;
+      bfd_signed_vma voff = 0;
+      boolean overflow;
+
+      /* Get the new reloc address.  */
+      nraddr = irel->r_offset;
+      if ((irel->r_offset > addr
+	   && irel->r_offset < toaddr)
+	  || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
+	      && irel->r_offset == toaddr))
+	nraddr -= count;
+
+      /* See if this reloc was for the bytes we have deleted, in which
+	 case we no longer care about it.  Don't delete relocs which
+	 represent addresses, though.  */
+      if (irel->r_offset >= addr
+	  && irel->r_offset < addr + count
+	  && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
+	  && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
+	  && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
+	  && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
+	irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+				     (int) R_SH_NONE);
+
+      /* If this is a PC relative reloc, see if the range it covers
+	 includes the bytes we have deleted.  */
+      switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
+	{
+	default:
+	  break;
+
+	case R_SH_DIR8WPN:
+	case R_SH_IND12W:
+	case R_SH_DIR8WPZ:
+	case R_SH_DIR8WPL:
+	  start = irel->r_offset;
+	  insn = bfd_get_16 (abfd, contents + nraddr);
+	  break;
+	}
+
+      switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
+	{
+	default:
+	  start = stop = addr;
+	  break;
+
+	case R_SH_DIR32:
+	  /* If this reloc is against a symbol defined in this
+	     section, and the symbol will not be adjusted below, we
+	     must check the addend to see it will put the value in
+	     range to be adjusted, and hence must be changed.  */
+	  if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
+	    {
+	      isym = isymbuf + ELF32_R_SYM (irel->r_info);
+	      if (isym->st_shndx == sec_shndx
+		  && (isym->st_value <= addr
+		      || isym->st_value >= toaddr))
+		{
+		  bfd_vma val;
+
+		  val = bfd_get_32 (abfd, contents + nraddr);
+		  val += isym->st_value;
+		  if (val > addr && val < toaddr)
+		    bfd_put_32 (abfd, val - count, contents + nraddr);
+		}
+	    }
+	  start = stop = addr;
+	  break;
+
+	case R_SH_DIR8WPN:
+	  off = insn & 0xff;
+	  if (off & 0x80)
+	    off -= 0x100;
+	  stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
+	  break;
+
+	case R_SH_IND12W:
+	  if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
+	    start = stop = addr;
+	  else
+	    {
+	      off = insn & 0xfff;
+	      if (off & 0x800)
+		off -= 0x1000;
+	      stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
+	    }
+	  break;
+
+	case R_SH_DIR8WPZ:
+	  off = insn & 0xff;
+	  stop = start + 4 + off * 2;
+	  break;
+
+	case R_SH_DIR8WPL:
+	  off = insn & 0xff;
+	  stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
+	  break;
+
+	case R_SH_SWITCH8:
+	case R_SH_SWITCH16:
+	case R_SH_SWITCH32:
+	  /* These relocs types represent
+	       .word L2-L1
+	     The r_addend field holds the difference between the reloc
+	     address and L1.  That is the start of the reloc, and
+	     adding in the contents gives us the top.  We must adjust
+	     both the r_offset field and the section contents.
+	     N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
+	     and the elf bfd r_offset is called r_vaddr.  */
+
+	  stop = irel->r_offset;
+	  start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
+
+	  if (start > addr
+	      && start < toaddr
+	      && (stop <= addr || stop >= toaddr))
+	    irel->r_addend += count;
+	  else if (stop > addr
+		   && stop < toaddr
+		   && (start <= addr || start >= toaddr))
+	    irel->r_addend -= count;
+
+	  if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
+	    voff = bfd_get_signed_16 (abfd, contents + nraddr);
+	  else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
+	    voff = bfd_get_8 (abfd, contents + nraddr);
+	  else
+	    voff = bfd_get_signed_32 (abfd, contents + nraddr);
+	  stop = (bfd_vma) ((bfd_signed_vma) start + voff);
+
+	  break;
+
+	case R_SH_USES:
+	  start = irel->r_offset;
+	  stop = (bfd_vma) ((bfd_signed_vma) start
+			    + (long) irel->r_addend
+			    + 4);
+	  break;
+	}
+
+      if (start > addr
+	  && start < toaddr
+	  && (stop <= addr || stop >= toaddr))
+	adjust = count;
+      else if (stop > addr
+	       && stop < toaddr
+	       && (start <= addr || start >= toaddr))
+	adjust = - count;
+      else
+	adjust = 0;
+
+      if (adjust != 0)
+	{
+	  oinsn = insn;
+	  overflow = false;
+	  switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
+	    {
+	    default:
+	      abort ();
+	      break;
+
+	    case R_SH_DIR8WPN:
+	    case R_SH_DIR8WPZ:
+	      insn += adjust / 2;
+	      if ((oinsn & 0xff00) != (insn & 0xff00))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
+	      break;
+
+	    case R_SH_IND12W:
+	      insn += adjust / 2;
+	      if ((oinsn & 0xf000) != (insn & 0xf000))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
+	      break;
+
+	    case R_SH_DIR8WPL:
+	      BFD_ASSERT (adjust == count || count >= 4);
+	      if (count >= 4)
+		insn += adjust / 4;
+	      else
+		{
+		  if ((irel->r_offset & 3) == 0)
+		    ++insn;
+		}
+	      if ((oinsn & 0xff00) != (insn & 0xff00))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
+	      break;
+
+	    case R_SH_SWITCH8:
+	      voff += adjust;
+	      if (voff < 0 || voff >= 0xff)
+		overflow = true;
+	      bfd_put_8 (abfd, voff, contents + nraddr);
+	      break;
+
+	    case R_SH_SWITCH16:
+	      voff += adjust;
+	      if (voff < - 0x8000 || voff >= 0x8000)
+		overflow = true;
+	      bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
+	      break;
+
+	    case R_SH_SWITCH32:
+	      voff += adjust;
+	      bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
+	      break;
+
+	    case R_SH_USES:
+	      irel->r_addend += adjust;
+	      break;
+	    }
+
+	  if (overflow)
+	    {
+	      ((*_bfd_error_handler)
+	       (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
+		bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+	}
+
+      irel->r_offset = nraddr;
+    }
+
+  /* Look through all the other sections.  If there contain any IMM32
+     relocs against internal symbols which we are not going to adjust
+     below, we may need to adjust the addends.  */
+  for (o = abfd->sections; o != NULL; o = o->next)
+    {
+      Elf_Internal_Rela *internal_relocs;
+      Elf_Internal_Rela *irelscan, *irelscanend;
+      bfd_byte *ocontents;
+
+      if (o == sec
+	  || (o->flags & SEC_RELOC) == 0
+	  || o->reloc_count == 0)
+	continue;
+
+      /* We always cache the relocs.  Perhaps, if info->keep_memory is
+	 false, we should free them, if we are permitted to, when we
+	 leave sh_coff_relax_section.  */
+      internal_relocs = (_bfd_elf32_link_read_relocs
+			 (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
+			  true));
+      if (internal_relocs == NULL)
+	return false;
+
+      ocontents = NULL;
+      irelscanend = internal_relocs + o->reloc_count;
+      for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
+	{
+	  /* Dwarf line numbers use R_SH_SWITCH32 relocs.  */
+	  if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
+	    {
+	      bfd_vma start, stop;
+	      bfd_signed_vma voff;
+
+	      if (ocontents == NULL)
+		{
+		  if (elf_section_data (o)->this_hdr.contents != NULL)
+		    ocontents = elf_section_data (o)->this_hdr.contents;
+		  else
+		    {
+		      /* We always cache the section contents.
+			 Perhaps, if info->keep_memory is false, we
+			 should free them, if we are permitted to,
+			 when we leave sh_coff_relax_section.  */
+		      ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
+		      if (ocontents == NULL)
+			return false;
+		      if (! bfd_get_section_contents (abfd, o, ocontents,
+						      (file_ptr) 0,
+						      o->_raw_size))
+			return false;
+		      elf_section_data (o)->this_hdr.contents = ocontents;
+		    }
+		}
+
+	      stop = irelscan->r_offset;
+	      start
+		= (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
+
+	      /* STOP is in a different section, so it won't change.  */
+	      if (start > addr && start < toaddr)
+		irelscan->r_addend += count;
+
+	      voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
+	      stop = (bfd_vma) ((bfd_signed_vma) start + voff);
+
+	      if (start > addr
+		  && start < toaddr
+		  && (stop <= addr || stop >= toaddr))
+		bfd_put_signed_32 (abfd, (bfd_vma) voff + count,
+				   ocontents + irelscan->r_offset);
+	      else if (stop > addr
+		       && stop < toaddr
+		       && (start <= addr || start >= toaddr))
+		bfd_put_signed_32 (abfd, (bfd_vma) voff - count,
+				   ocontents + irelscan->r_offset);
+	    }
+
+	  if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
+	    continue;
+
+	  if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
+	    continue;
+
+
+	  isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
+	  if (isym->st_shndx == sec_shndx
+	      && (isym->st_value <= addr
+		  || isym->st_value >= toaddr))
+	    {
+	      bfd_vma val;
+
+	      if (ocontents == NULL)
+		{
+		  if (elf_section_data (o)->this_hdr.contents != NULL)
+		    ocontents = elf_section_data (o)->this_hdr.contents;
+		  else
+		    {
+		      /* We always cache the section contents.
+			 Perhaps, if info->keep_memory is false, we
+			 should free them, if we are permitted to,
+			 when we leave sh_coff_relax_section.  */
+		      ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
+		      if (ocontents == NULL)
+			return false;
+		      if (! bfd_get_section_contents (abfd, o, ocontents,
+						      (file_ptr) 0,
+						      o->_raw_size))
+			return false;
+		      elf_section_data (o)->this_hdr.contents = ocontents;
+		    }
+		}
+
+	      val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
+	      val += isym->st_value;
+	      if (val > addr && val < toaddr)
+		bfd_put_32 (abfd, val - count,
+			    ocontents + irelscan->r_offset);
+	    }
+	}
+    }
+
+  /* Adjust the local symbols defined in this section.  */
+  isymend = isymbuf + symtab_hdr->sh_info;
+  for (isym = isymbuf; isym < isymend; isym++)
+    {
+      if (isym->st_shndx == sec_shndx
+	  && isym->st_value > addr
+	  && isym->st_value < toaddr)
+	isym->st_value -= count;
+    }
+
+  /* Now adjust the global symbols defined in this section.  */
+  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
+	      - symtab_hdr->sh_info);
+  sym_hashes = elf_sym_hashes (abfd);
+  end_hashes = sym_hashes + symcount;
+  for (; sym_hashes < end_hashes; sym_hashes++)
+    {
+      struct elf_link_hash_entry *sym_hash = *sym_hashes;
+      if ((sym_hash->root.type == bfd_link_hash_defined
+	   || sym_hash->root.type == bfd_link_hash_defweak)
+	  && sym_hash->root.u.def.section == sec
+	  && sym_hash->root.u.def.value > addr
+	  && sym_hash->root.u.def.value < toaddr)
+	{
+	  sym_hash->root.u.def.value -= count;
+	}
+    }
+
+  /* See if we can move the ALIGN reloc forward.  We have adjusted
+     r_offset for it already.  */
+  if (irelalign != NULL)
+    {
+      bfd_vma alignto, alignaddr;
+
+      alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
+      alignaddr = BFD_ALIGN (irelalign->r_offset,
+			     1 << irelalign->r_addend);
+      if (alignto != alignaddr)
+	{
+	  /* Tail recursion.  */
+	  return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
+					    (int) (alignto - alignaddr));
+	}
+    }
+
+  return true;
+}
+
+/* Look for loads and stores which we can align to four byte
+   boundaries.  This is like sh_align_loads in coff-sh.c.  */
+
+static boolean
+sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     asection *sec;
+     Elf_Internal_Rela *internal_relocs;
+     bfd_byte *contents ATTRIBUTE_UNUSED;
+     boolean *pswapped;
+{
+  Elf_Internal_Rela *irel, *irelend;
+  bfd_vma *labels = NULL;
+  bfd_vma *label, *label_end;
+  bfd_size_type amt;
+
+  *pswapped = false;
+
+  irelend = internal_relocs + sec->reloc_count;
+
+  /* Get all the addresses with labels on them.  */
+  amt = sec->reloc_count;
+  amt *= sizeof (bfd_vma);
+  labels = (bfd_vma *) bfd_malloc (amt);
+  if (labels == NULL)
+    goto error_return;
+  label_end = labels;
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
+	{
+	  *label_end = irel->r_offset;
+	  ++label_end;
+	}
+    }
+
+  /* Note that the assembler currently always outputs relocs in
+     address order.  If that ever changes, this code will need to sort
+     the label values and the relocs.  */
+
+  label = labels;
+
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      bfd_vma start, stop;
+
+      if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
+	continue;
+
+      start = irel->r_offset;
+
+      for (irel++; irel < irelend; irel++)
+	if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
+	  break;
+      if (irel < irelend)
+	stop = irel->r_offset;
+      else
+	stop = sec->_cooked_size;
+
+      if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
+				     (PTR) internal_relocs, &label,
+				     label_end, start, stop, pswapped))
+	goto error_return;
+    }
+
+  free (labels);
+
+  return true;
+
+ error_return:
+  if (labels != NULL)
+    free (labels);
+  return false;
+}
+
+/* Swap two SH instructions.  This is like sh_swap_insns in coff-sh.c.  */
+
+static boolean
+sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
+     bfd *abfd;
+     asection *sec;
+     PTR relocs;
+     bfd_byte *contents;
+     bfd_vma addr;
+{
+  Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
+  unsigned short i1, i2;
+  Elf_Internal_Rela *irel, *irelend;
+
+  /* Swap the instructions themselves.  */
+  i1 = bfd_get_16 (abfd, contents + addr);
+  i2 = bfd_get_16 (abfd, contents + addr + 2);
+  bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
+  bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
+
+  /* Adjust all reloc addresses.  */
+  irelend = internal_relocs + sec->reloc_count;
+  for (irel = internal_relocs; irel < irelend; irel++)
+    {
+      enum elf_sh_reloc_type type;
+      int add;
+
+      /* There are a few special types of relocs that we don't want to
+	 adjust.  These relocs do not apply to the instruction itself,
+	 but are only associated with the address.  */
+      type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
+      if (type == R_SH_ALIGN
+	  || type == R_SH_CODE
+	  || type == R_SH_DATA
+	  || type == R_SH_LABEL)
+	continue;
+
+      /* If an R_SH_USES reloc points to one of the addresses being
+	 swapped, we must adjust it.  It would be incorrect to do this
+	 for a jump, though, since we want to execute both
+	 instructions after the jump.  (We have avoided swapping
+	 around a label, so the jump will not wind up executing an
+	 instruction it shouldn't).  */
+      if (type == R_SH_USES)
+	{
+	  bfd_vma off;
+
+	  off = irel->r_offset + 4 + irel->r_addend;
+	  if (off == addr)
+	    irel->r_offset += 2;
+	  else if (off == addr + 2)
+	    irel->r_offset -= 2;
+	}
+
+      if (irel->r_offset == addr)
+	{
+	  irel->r_offset += 2;
+	  add = -2;
+	}
+      else if (irel->r_offset == addr + 2)
+	{
+	  irel->r_offset -= 2;
+	  add = 2;
+	}
+      else
+	add = 0;
+
+      if (add != 0)
+	{
+	  bfd_byte *loc;
+	  unsigned short insn, oinsn;
+	  boolean overflow;
+
+	  loc = contents + irel->r_offset;
+	  overflow = false;
+	  switch (type)
+	    {
+	    default:
+	      break;
+
+	    case R_SH_DIR8WPN:
+	    case R_SH_DIR8WPZ:
+	      insn = bfd_get_16 (abfd, loc);
+	      oinsn = insn;
+	      insn += add / 2;
+	      if ((oinsn & 0xff00) != (insn & 0xff00))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, loc);
+	      break;
+
+	    case R_SH_IND12W:
+	      insn = bfd_get_16 (abfd, loc);
+	      oinsn = insn;
+	      insn += add / 2;
+	      if ((oinsn & 0xf000) != (insn & 0xf000))
+		overflow = true;
+	      bfd_put_16 (abfd, (bfd_vma) insn, loc);
+	      break;
+
+	    case R_SH_DIR8WPL:
+	      /* This reloc ignores the least significant 3 bits of
+		 the program counter before adding in the offset.
+		 This means that if ADDR is at an even address, the
+		 swap will not affect the offset.  If ADDR is an at an
+		 odd address, then the instruction will be crossing a
+		 four byte boundary, and must be adjusted.  */
+	      if ((addr & 3) != 0)
+		{
+		  insn = bfd_get_16 (abfd, loc);
+		  oinsn = insn;
+		  insn += add / 2;
+		  if ((oinsn & 0xff00) != (insn & 0xff00))
+		    overflow = true;
+		  bfd_put_16 (abfd, (bfd_vma) insn, loc);
+		}
+
+	      break;
+	    }
+
+	  if (overflow)
+	    {
+	      ((*_bfd_error_handler)
+	       (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
+		bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+	}
+    }
+
+  return true;
+}
+
+#ifdef INCLUDE_SHMEDIA
+
+/* The size in bytes of an entry in the procedure linkage table.  */
+
+#define PLT_ENTRY_SIZE 64
+
+/* First entry in an absolute procedure linkage table look like this.  */
+
+static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xcc, 0x00, 0x01, 0x10, /* movi  .got.plt >> 16, r17 */
+  0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
+  0x89, 0x10, 0x09, 0x90, /* ld.l  r17, 8, r25 */
+  0x6b, 0xf1, 0x46, 0x00, /* ptabs r17, tr0 */
+  0x89, 0x10, 0x05, 0x10, /* ld.l  r17, 4, r17 */
+  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+};
+
+static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x10, 0x01, 0x00, 0xcc, /* movi  .got.plt >> 16, r17 */
+  0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
+  0x90, 0x09, 0x10, 0x89, /* ld.l  r17, 8, r25 */
+  0x00, 0x46, 0xf1, 0x6b, /* ptabs r17, tr0 */
+  0x10, 0x05, 0x10, 0x89, /* ld.l  r17, 4, r17 */
+  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+};
+
+/* Sebsequent entries in an absolute procedure linkage table look like
+   this.  */
+
+static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xcc, 0x00, 0x01, 0x90, /* movi  nameN-in-GOT >> 16, r25 */
+  0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
+  0x89, 0x90, 0x01, 0x90, /* ld.l  r25, 0, r25 */
+  0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
+  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0xcc, 0x00, 0x01, 0x90, /* movi  .PLT0 >> 16, r25 */
+  0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
+  0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
+  0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
+  0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
+  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+};
+
+static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x90, 0x01, 0x00, 0xcc, /* movi  nameN-in-GOT >> 16, r25 */
+  0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
+  0x90, 0x01, 0x90, 0x89, /* ld.l  r25, 0, r25 */
+  0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
+  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0x90, 0x01, 0x00, 0xcc, /* movi  .PLT0 >> 16, r25 */
+  0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
+  0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
+  0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
+  0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
+  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+};
+
+/* Entries in a PIC procedure linkage table look like this.  */
+
+static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xcc, 0x00, 0x01, 0x90, /* movi  nameN@GOT >> 16, r25 */
+  0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
+  0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
+  0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
+  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0x6f, 0xf0, 0xff, 0xf0, /* nop */
+  0xce, 0x00, 0x01, 0x10, /* movi  -GOT_BIAS, r17 */
+  0x00, 0xca, 0x45, 0x10, /* sub.l r12, r17, r17 */
+  0x89, 0x10, 0x09, 0x90, /* ld.l  r17, 8, r25 */
+  0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
+  0x89, 0x10, 0x05, 0x10, /* ld.l  r17, 4, r17 */
+  0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
+  0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
+  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
+};
+
+static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x90, 0x01, 0x00, 0xcc, /* movi  nameN@GOT >> 16, r25 */
+  0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
+  0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
+  0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
+  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0xf0, 0xff, 0xf0, 0x6f, /* nop */
+  0x10, 0x01, 0x00, 0xce, /* movi  -GOT_BIAS, r17 */
+  0x10, 0x45, 0xca, 0x00, /* sub.l r12, r17, r17 */
+  0x90, 0x09, 0x10, 0x89, /* ld.l  r17, 8, r25 */
+  0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
+  0x10, 0x05, 0x10, 0x89, /* ld.l  r17, 4, r17 */
+  0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
+  0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
+  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
+};
+
+static const bfd_byte *elf_sh_plt0_entry;
+static const bfd_byte *elf_sh_plt_entry;
+static const bfd_byte *elf_sh_pic_plt_entry;
+
+/* Return size of a PLT entry.  */
+#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
+
+/* Return offset of the PLT0 address in an absolute PLT entry.  */
+#define elf_sh_plt_plt0_offset(info) 32
+
+/* Return offset of the linker in PLT0 entry.  */
+#define elf_sh_plt0_gotplt_offset(info) 0
+
+/* Return offset of the trampoline in PLT entry */
+#define elf_sh_plt_temp_offset(info) 33 /* Add one because it's SHmedia.  */
+
+/* Return offset of the symbol in PLT entry.  */
+#define elf_sh_plt_symbol_offset(info) 0
+
+/* Return offset of the relocation in PLT entry.  */
+#define elf_sh_plt_reloc_offset(info) (info->shared ? 52 : 44)
+
+inline static void
+movi_shori_putval (output_bfd, value, addr)
+     bfd *output_bfd;
+     unsigned long value;
+     char *addr;
+{
+  bfd_put_32 (output_bfd,
+	      bfd_get_32 (output_bfd, addr)
+	      | ((value >> 6) & 0x3fffc00),
+	      addr);
+  bfd_put_32 (output_bfd,
+	      bfd_get_32 (output_bfd, addr + 4)
+	      | ((value << 10) & 0x3fffc00),
+	      addr + 4);
+}
+
+#else
+/* The size in bytes of an entry in the procedure linkage table.  */
+
+#define PLT_ENTRY_SIZE 28
+
+/* First entry in an absolute procedure linkage table look like this.  */
+
+#if 1
+/* Note - this code has been "optimised" not to use r2.  r2 is used by
+   GCC to return the address of large strutcures, so it should not be
+   corrupted here.  This does mean however, that this PLT does not conform
+   to the SH PIC ABI.  That spec says that r0 contains the type of the PLT
+   and r2 contains the GOT id.  This version stores the GOT id in r0 and
+   ignores the type.  Loaders can easily detect this difference however,
+   since the type will always be 0 or 8, and the GOT ids will always be
+   greater than or equal to 12.  */
+static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xd0, 0x05,	/* mov.l 2f,r0 */
+  0x60, 0x02,	/* mov.l @r0,r0 */
+  0x2f, 0x06,	/* mov.l r0,@-r15 */
+  0xd0, 0x03,	/* mov.l 1f,r0 */
+  0x60, 0x02,	/* mov.l @r0,r0 */
+  0x40, 0x2b,	/* jmp @r0 */
+  0x60, 0xf6,	/*  mov.l @r15+,r0 */
+  0x00, 0x09,	/* nop */
+  0x00, 0x09,	/* nop */
+  0x00, 0x09,	/* nop */
+  0, 0, 0, 0,	/* 1: replaced with address of .got.plt + 8.  */
+  0, 0, 0, 0,	/* 2: replaced with address of .got.plt + 4.  */
+};
+
+static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x05, 0xd0,	/* mov.l 2f,r0 */
+  0x02, 0x60,	/* mov.l @r0,r0 */
+  0x06, 0x2f,	/* mov.l r0,@-r15 */
+  0x03, 0xd0,	/* mov.l 1f,r0 */
+  0x02, 0x60,	/* mov.l @r0,r0 */
+  0x2b, 0x40,	/* jmp @r0 */
+  0xf6, 0x60,	/*  mov.l @r15+,r0 */
+  0x09, 0x00,	/* nop */
+  0x09, 0x00,	/* nop */
+  0x09, 0x00,	/* nop */
+  0, 0, 0, 0,	/* 1: replaced with address of .got.plt + 8.  */
+  0, 0, 0, 0,	/* 2: replaced with address of .got.plt + 4.  */
+};
+
+/* Sebsequent entries in an absolute procedure linkage table look like
+   this.  */
+
+static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xd0, 0x04,	/* mov.l 1f,r0 */
+  0x60, 0x02,	/* mov.l @r0,r0 */
+  0xd1, 0x02,	/* mov.l 0f,r1 */
+  0x40, 0x2b,   /* jmp @r0 */
+  0x60, 0x13,	/*  mov r1,r0 */
+  0xd1, 0x03,	/* mov.l 2f,r1 */
+  0x40, 0x2b,	/* jmp @r0 */
+  0x00, 0x09,	/* nop */
+  0, 0, 0, 0,	/* 0: replaced with address of .PLT0.  */
+  0, 0, 0, 0,	/* 1: replaced with address of this symbol in .got.  */
+  0, 0, 0, 0,	/* 2: replaced with offset into relocation table.  */
+};
+
+static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x04, 0xd0,	/* mov.l 1f,r0 */
+  0x02, 0x60,	/* mov.l @r0,r0 */
+  0x02, 0xd1,	/* mov.l 0f,r1 */
+  0x2b, 0x40,   /* jmp @r0 */
+  0x13, 0x60,	/*  mov r1,r0 */
+  0x03, 0xd1,	/* mov.l 2f,r1 */
+  0x2b, 0x40,	/* jmp @r0 */
+  0x09, 0x00,	/*  nop */
+  0, 0, 0, 0,	/* 0: replaced with address of .PLT0.  */
+  0, 0, 0, 0,	/* 1: replaced with address of this symbol in .got.  */
+  0, 0, 0, 0,	/* 2: replaced with offset into relocation table.  */
+};
+
+/* Entries in a PIC procedure linkage table look like this.  */
+
+static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xd0, 0x04,	/* mov.l 1f,r0 */
+  0x00, 0xce,	/* mov.l @(r0,r12),r0 */
+  0x40, 0x2b,	/* jmp @r0 */
+  0x00, 0x09,	/*  nop */
+  0x50, 0xc2,	/* mov.l @(8,r12),r0 */
+  0xd1, 0x03,	/* mov.l 2f,r1 */
+  0x40, 0x2b,	/* jmp @r0 */
+  0x50, 0xc1,	/*  mov.l @(4,r12),r0 */
+  0x00, 0x09,	/* nop */
+  0x00, 0x09,	/* nop */
+  0, 0, 0, 0,	/* 1: replaced with address of this symbol in .got.  */
+  0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
+};
+
+static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x04, 0xd0,	/* mov.l 1f,r0 */
+  0xce, 0x00,	/* mov.l @(r0,r12),r0 */
+  0x2b, 0x40,	/* jmp @r0 */
+  0x09, 0x00,	/*  nop */
+  0xc2, 0x50,	/* mov.l @(8,r12),r0 */
+  0x03, 0xd1,	/* mov.l 2f,r1 */
+  0x2b, 0x40,	/* jmp @r0 */
+  0xc1, 0x50,	/*  mov.l @(4,r12),r0 */
+  0x09, 0x00,	/*  nop */
+  0x09, 0x00,	/* nop */
+  0, 0, 0, 0,	/* 1: replaced with address of this symbol in .got.  */
+  0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
+};
+
+#else /* These are the old style PLT entries.  */
+static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xd0, 0x04,	/* mov.l 1f,r0 */
+  0xd2, 0x05,	/* mov.l 2f,r2 */
+  0x60, 0x02,	/* mov.l @r0,r0 */
+  0x62, 0x22,	/* mov.l @r2,r2 */
+  0x40, 0x2b,	/* jmp @r0 */
+  0xe0, 0x00,	/*  mov #0,r0 */
+  0x00, 0x09,	/* nop */
+  0x00, 0x09,	/* nop */
+  0x00, 0x09,	/* nop */
+  0x00, 0x09,	/* nop */
+  0, 0, 0, 0,	/* 1: replaced with address of .got.plt + 8.  */
+  0, 0, 0, 0,	/* 2: replaced with address of .got.plt + 4.  */
+};
+
+static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x04, 0xd0,	/* mov.l 1f,r0 */
+  0x05, 0xd2,	/* mov.l 2f,r2 */
+  0x02, 0x60,	/* mov.l @r0,r0 */
+  0x22, 0x62,	/* mov.l @r2,r2 */
+  0x2b, 0x40,	/* jmp @r0 */
+  0x00, 0xe0,	/*  mov #0,r0 */
+  0x09, 0x00,	/* nop */
+  0x09, 0x00,	/* nop */
+  0x09, 0x00,	/* nop */
+  0x09, 0x00,	/* nop */
+  0, 0, 0, 0,	/* 1: replaced with address of .got.plt + 8.  */
+  0, 0, 0, 0,	/* 2: replaced with address of .got.plt + 4.  */
+};
+
+/* Sebsequent entries in an absolute procedure linkage table look like
+   this.  */
+
+static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xd0, 0x04,	/* mov.l 1f,r0 */
+  0x60, 0x02,	/* mov.l @r0,r0 */
+  0xd2, 0x02,	/* mov.l 0f,r2 */
+  0x40, 0x2b,   /* jmp @r0 */
+  0x60, 0x23,	/*  mov r2,r0 */
+  0xd1, 0x03,	/* mov.l 2f,r1 */
+  0x40, 0x2b,	/* jmp @r0 */
+  0x00, 0x09,	/* nop */
+  0, 0, 0, 0,	/* 0: replaced with address of .PLT0.  */
+  0, 0, 0, 0,	/* 1: replaced with address of this symbol in .got.  */
+  0, 0, 0, 0,	/* 2: replaced with offset into relocation table.  */
+};
+
+static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x04, 0xd0,	/* mov.l 1f,r0 */
+  0x02, 0x60,	/* mov.l @r0,r0 */
+  0x02, 0xd2,	/* mov.l 0f,r2 */
+  0x2b, 0x40,   /* jmp @r0 */
+  0x23, 0x60,	/*  mov r2,r0 */
+  0x03, 0xd1,	/* mov.l 2f,r1 */
+  0x2b, 0x40,	/* jmp @r0 */
+  0x09, 0x00,	/*  nop */
+  0, 0, 0, 0,	/* 0: replaced with address of .PLT.  */
+  0, 0, 0, 0,	/* 1: replaced with address of this symbol in .got.  */
+  0, 0, 0, 0,	/* 2: replaced with offset into relocation table.  */
+};
+
+/* Entries in a PIC procedure linkage table look like this.  */
+
+static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
+{
+  0xd0, 0x04,	/* mov.l 1f,r0 */
+  0x00, 0xce,	/* mov.l @(r0,r12),r0 */
+  0x40, 0x2b,	/* jmp @r0 */
+  0x00, 0x09,	/*  nop */
+  0x50, 0xc2,	/* 0: mov.l @(8,r12),r0 */
+  0x52, 0xc1,	/* 1: mov.l @(4,r12),r2 */
+  0xd1, 0x02,	/* mov.l 2f,r1 */
+  0x40, 0x2b,	/* jmp @r0 */
+  0xe0, 0x00,	/*  mov #0,r0 ! shows the type of PLT.  */
+  0x00, 0x09,	/* nop */
+  0, 0, 0, 0,	/* 1: replaced with address of this symbol in .got.  */
+  0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
+};
+
+static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
+{
+  0x04, 0xd0,	/* mov.l 1f,r0 */
+  0xce, 0x00,	/* mov.l @(r0,r12),r0 */
+  0x2b, 0x40,	/* jmp @r0 */
+  0x09, 0x00,	/*  nop */
+  0xc2, 0x50,	/* 0: mov.l @(8,r12),r0 */
+  0xc1, 0x52,	/* 1: mov.l @(4,r12),r2 */
+  0x02, 0xd1,	/* mov.l 2f,r1 */
+  0x2b, 0x40,	/* jmp @r0 */
+  0x00, 0xe0,	/*  mov #0,r0 ! shows the type of PLT.  */
+  0x09, 0x00,	/* nop */
+  0, 0, 0, 0,	/* 1: replaced with address of this symbol in .got.  */
+  0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
+};
+#endif /* old style PLT entries.  */
+
+static const bfd_byte *elf_sh_plt0_entry;
+static const bfd_byte *elf_sh_plt_entry;
+static const bfd_byte *elf_sh_pic_plt_entry;
+
+/* Return size of a PLT entry.  */
+#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
+
+/* Return offset of the PLT0 address in an absolute PLT entry.  */
+#define elf_sh_plt_plt0_offset(info) 16
+
+/* Return offset of the linker in PLT0 entry.  */
+#define elf_sh_plt0_linker_offset(info) 20
+
+/* Return offset of the GOT id in PLT0 entry.  */
+#define elf_sh_plt0_gotid_offset(info) 24
+
+/* Return offset of the tempoline in PLT entry */
+#define elf_sh_plt_temp_offset(info) 8
+
+/* Return offset of the symbol in PLT entry.  */
+#define elf_sh_plt_symbol_offset(info) 20
+
+/* Return offset of the relocation in PLT entry.  */
+#define elf_sh_plt_reloc_offset(info) 24
+#endif
+
+/* The sh linker needs to keep track of the number of relocs that it
+   decides to copy as dynamic relocs in check_relocs for each symbol.
+   This is so that it can later discard them if they are found to be
+   unnecessary.  We store the information in a field extending the
+   regular ELF linker hash table.  */
+
+struct elf_sh_dyn_relocs
+{
+  struct elf_sh_dyn_relocs *next;
+
+  /* The input section of the reloc.  */
+  asection *sec;
+
+  /* Total number of relocs copied for the input section.  */
+  bfd_size_type count;
+
+  /* Number of pc-relative relocs copied for the input section.  */
+  bfd_size_type pc_count;
+};
+
+/* sh ELF linker hash entry.  */
+
+struct elf_sh_link_hash_entry
+{
+  struct elf_link_hash_entry root;
+
+#ifdef INCLUDE_SHMEDIA
+  bfd_vma datalabel_got_offset;
+#endif
+
+  /* Track dynamic relocs copied for this symbol.  */
+  struct elf_sh_dyn_relocs *dyn_relocs;
+
+  bfd_signed_vma gotplt_refcount;
+};
+
+/* sh ELF linker hash table.  */
+
+struct elf_sh_link_hash_table
+{
+  struct elf_link_hash_table root;
+
+  /* Short-cuts to get to dynamic linker sections.  */
+  asection *sgot;
+  asection *sgotplt;
+  asection *srelgot;
+  asection *splt;
+  asection *srelplt;
+  asection *sdynbss;
+  asection *srelbss;
+
+  /* Small local sym to section mapping cache.  */
+  struct sym_sec_cache sym_sec;
+};
+
+/* Traverse an sh ELF linker hash table.  */
+
+#define sh_elf_link_hash_traverse(table, func, info)			\
+  (elf_link_hash_traverse						\
+   (&(table)->root,							\
+    (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),	\
+    (info)))
+
+/* Get the sh ELF linker hash table from a link_info structure.  */
+
+#define sh_elf_hash_table(p) \
+  ((struct elf_sh_link_hash_table *) ((p)->hash))
+
+/* Create an entry in an sh ELF linker hash table.  */
+
+static struct bfd_hash_entry *
+sh_elf_link_hash_newfunc (entry, table, string)
+     struct bfd_hash_entry *entry;
+     struct bfd_hash_table *table;
+     const char *string;
+{
+  struct elf_sh_link_hash_entry *ret =
+    (struct elf_sh_link_hash_entry *) entry;
+
+  /* Allocate the structure if it has not already been allocated by a
+     subclass.  */
+  if (ret == (struct elf_sh_link_hash_entry *) NULL)
+    ret = ((struct elf_sh_link_hash_entry *)
+	   bfd_hash_allocate (table,
+			      sizeof (struct elf_sh_link_hash_entry)));
+  if (ret == (struct elf_sh_link_hash_entry *) NULL)
+    return (struct bfd_hash_entry *) ret;
+
+  /* Call the allocation method of the superclass.  */
+  ret = ((struct elf_sh_link_hash_entry *)
+	 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
+				     table, string));
+  if (ret != (struct elf_sh_link_hash_entry *) NULL)
+    {
+      struct elf_sh_link_hash_entry *eh;
+
+      eh = (struct elf_sh_link_hash_entry *) ret;
+      eh->dyn_relocs = NULL;
+      eh->gotplt_refcount = 0;
+#ifdef INCLUDE_SHMEDIA
+      ret->datalabel_got_offset = (bfd_vma) -1;
+#endif
+    }
+
+  return (struct bfd_hash_entry *) ret;
+}
+
+/* Create an sh ELF linker hash table.  */
+
+static struct bfd_link_hash_table *
+sh_elf_link_hash_table_create (abfd)
+     bfd *abfd;
+{
+  struct elf_sh_link_hash_table *ret;
+  bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
+
+  ret = (struct elf_sh_link_hash_table *) bfd_malloc (amt);
+  if (ret == (struct elf_sh_link_hash_table *) NULL)
+    return NULL;
+
+  if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
+				       sh_elf_link_hash_newfunc))
+    {
+      free (ret);
+      return NULL;
+    }
+
+  ret->sgot = NULL;
+  ret->sgotplt = NULL;
+  ret->srelgot = NULL;
+  ret->splt = NULL;
+  ret->srelplt = NULL;
+  ret->sdynbss = NULL;
+  ret->srelbss = NULL;
+  ret->sym_sec.abfd = NULL;
+
+  return &ret->root.root;
+}
+
+/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
+   shortcuts to them in our hash table.  */
+
+static boolean
+create_got_section (dynobj, info)
+     bfd *dynobj;
+     struct bfd_link_info *info;
+{
+  struct elf_sh_link_hash_table *htab;
+
+  if (! _bfd_elf_create_got_section (dynobj, info))
+    return false;
+
+  htab = sh_elf_hash_table (info);
+  htab->sgot = bfd_get_section_by_name (dynobj, ".got");
+  htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
+  if (! htab->sgot || ! htab->sgotplt)
+    abort ();
+
+  htab->srelgot = bfd_make_section (dynobj, ".rela.got");
+  if (htab->srelgot == NULL
+      || ! bfd_set_section_flags (dynobj, htab->srelgot,
+				  (SEC_ALLOC
+				   | SEC_LOAD
+				   | SEC_HAS_CONTENTS
+				   | SEC_IN_MEMORY
+				   | SEC_LINKER_CREATED
+				   | SEC_READONLY))
+      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
+    return false;
+  return true;
+}
+
+/* Create dynamic sections when linking against a dynamic object.  */
+
+static boolean
+sh_elf_create_dynamic_sections (abfd, info)
+     bfd *abfd;
+     struct bfd_link_info *info;
+{
+  struct elf_sh_link_hash_table *htab;
+  flagword flags, pltflags;
+  register asection *s;
+  struct elf_backend_data *bed = get_elf_backend_data (abfd);
+  int ptralign = 0;
+
+  switch (bed->s->arch_size)
+    {
+    case 32:
+      ptralign = 2;
+      break;
+
+    case 64:
+      ptralign = 3;
+      break;
+
+    default:
+      bfd_set_error (bfd_error_bad_value);
+      return false;
+    }
+
+  htab = sh_elf_hash_table (info);
+
+  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
+     .rel[a].bss sections.  */
+
+  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
+	   | SEC_LINKER_CREATED);
+
+  pltflags = flags;
+  pltflags |= SEC_CODE;
+  if (bed->plt_not_loaded)
+    pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
+  if (bed->plt_readonly)
+    pltflags |= SEC_READONLY;
+
+  s = bfd_make_section (abfd, ".plt");
+  htab->splt = s;
+  if (s == NULL
+      || ! bfd_set_section_flags (abfd, s, pltflags)
+      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
+    return false;
+
+  if (bed->want_plt_sym)
+    {
+      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
+	 .plt section.  */
+      struct elf_link_hash_entry *h;
+      struct bfd_link_hash_entry *bh = NULL;
+
+      if (! (_bfd_generic_link_add_one_symbol
+	     (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
+	      (bfd_vma) 0, (const char *) NULL, false,
+	      get_elf_backend_data (abfd)->collect, &bh)))
+	return false;
+
+      h = (struct elf_link_hash_entry *) bh;
+      h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
+      h->type = STT_OBJECT;
+
+      if (info->shared
+	  && ! _bfd_elf_link_record_dynamic_symbol (info, h))
+	return false;
+    }
+
+  s = bfd_make_section (abfd,
+			bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
+  htab->srelplt = s;
+  if (s == NULL
+      || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
+      || ! bfd_set_section_alignment (abfd, s, ptralign))
+    return false;
+
+  if (! create_got_section (abfd, info))
+    return false;
+
+  {
+    const char *secname;
+    char *relname;
+    flagword secflags;
+    asection *sec;
+
+    for (sec = abfd->sections; sec; sec = sec->next)
+      {
+	secflags = bfd_get_section_flags (abfd, sec);
+	if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
+	    || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
+	  continue;
+	secname = bfd_get_section_name (abfd, sec);
+	relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
+	strcpy (relname, ".rela");
+	strcat (relname, secname);
+	s = bfd_make_section (abfd, relname);
+	if (s == NULL
+	    || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
+	    || ! bfd_set_section_alignment (abfd, s, ptralign))
+	  return false;
+      }
+  }
+
+  if (bed->want_dynbss)
+    {
+      /* The .dynbss section is a place to put symbols which are defined
+	 by dynamic objects, are referenced by regular objects, and are
+	 not functions.  We must allocate space for them in the process
+	 image and use a R_*_COPY reloc to tell the dynamic linker to
+	 initialize them at run time.  The linker script puts the .dynbss
+	 section into the .bss section of the final image.  */
+      s = bfd_make_section (abfd, ".dynbss");
+      htab->sdynbss = s;
+      if (s == NULL
+	  || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
+	return false;
+
+      /* The .rel[a].bss section holds copy relocs.  This section is not
+	 normally needed.  We need to create it here, though, so that the
+	 linker will map it to an output section.  We can't just create it
+	 only if we need it, because we will not know whether we need it
+	 until we have seen all the input files, and the first time the
+	 main linker code calls BFD after examining all the input files
+	 (size_dynamic_sections) the input sections have already been
+	 mapped to the output sections.  If the section turns out not to
+	 be needed, we can discard it later.  We will never need this
+	 section when generating a shared object, since they do not use
+	 copy relocs.  */
+      if (! info->shared)
+	{
+	  s = bfd_make_section (abfd,
+				(bed->default_use_rela_p
+				 ? ".rela.bss" : ".rel.bss"));
+	  htab->srelbss = s;
+	  if (s == NULL
+	      || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
+	      || ! bfd_set_section_alignment (abfd, s, ptralign))
+	    return false;
+	}
+    }
+
+  return true;
+}
+
+/* Adjust a symbol defined by a dynamic object and referenced by a
+   regular object.  The current definition is in some section of the
+   dynamic object, but we're not including those sections.  We have to
+   change the definition to something the rest of the link can
+   understand.  */
+
+static boolean
+sh_elf_adjust_dynamic_symbol (info, h)
+     struct bfd_link_info *info;
+     struct elf_link_hash_entry *h;
+{
+  struct elf_sh_link_hash_table *htab;
+  struct elf_sh_link_hash_entry *eh;
+  struct elf_sh_dyn_relocs *p;
+  bfd *dynobj;
+  asection *s;
+  unsigned int power_of_two;
+
+  dynobj = elf_hash_table (info)->dynobj;
+
+  /* Make sure we know what is going on here.  */
+  BFD_ASSERT (dynobj != NULL
+	      && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
+		  || h->weakdef != NULL
+		  || ((h->elf_link_hash_flags
+		       & ELF_LINK_HASH_DEF_DYNAMIC) != 0
+		      && (h->elf_link_hash_flags
+			  & ELF_LINK_HASH_REF_REGULAR) != 0
+		      && (h->elf_link_hash_flags
+			  & ELF_LINK_HASH_DEF_REGULAR) == 0)));
+
+  /* If this is a function, put it in the procedure linkage table.  We
+     will fill in the contents of the procedure linkage table later,
+     when we know the address of the .got section.  */
+  if (h->type == STT_FUNC
+      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
+    {
+      if (h->plt.refcount <= 0
+	  || (! info->shared
+	      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
+	      && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
+	      && h->root.type != bfd_link_hash_undefweak
+	      && h->root.type != bfd_link_hash_undefined))
+	{
+	  /* This case can occur if we saw a PLT reloc in an input
+	     file, but the symbol was never referred to by a dynamic
+	     object.  In such a case, we don't actually need to build
+	     a procedure linkage table, and we can just do a REL32
+	     reloc instead.  */
+	  h->plt.offset = (bfd_vma) -1;
+	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+	}
+
+      return true;
+    }
+  else
+    h->plt.offset = (bfd_vma) -1;
+
+  /* If this is a weak symbol, and there is a real definition, the
+     processor independent code will have arranged for us to see the
+     real definition first, and we can just use the same value.  */
+  if (h->weakdef != NULL)
+    {
+      BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
+		  || h->weakdef->root.type == bfd_link_hash_defweak);
+      h->root.u.def.section = h->weakdef->root.u.def.section;
+      h->root.u.def.value = h->weakdef->root.u.def.value;
+      return true;
+    }
+
+  /* This is a reference to a symbol defined by a dynamic object which
+     is not a function.  */
+
+  /* If we are creating a shared library, we must presume that the
+     only references to the symbol are via the global offset table.
+     For such cases we need not do anything here; the relocations will
+     be handled correctly by relocate_section.  */
+  if (info->shared)
+    return true;
+
+  /* If there are no references to this symbol that do not use the
+     GOT, we don't need to generate a copy reloc.  */
+  if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
+    return true;
+
+  /* If -z nocopyreloc was given, we won't generate them either.  */
+  if (info->nocopyreloc)
+    {
+      h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
+      return true;
+    }
+
+  eh = (struct elf_sh_link_hash_entry *) h;
+  for (p = eh->dyn_relocs; p != NULL; p = p->next)
+    {
+      s = p->sec->output_section;
+      if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
+	break;
+    }
+
+  /* If we didn't find any dynamic relocs in sections which needs the
+     copy reloc, then we'll be keeping the dynamic relocs and avoiding
+     the copy reloc.  */
+  if (p == NULL)
+    {
+      h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
+      return true;
+    }
+
+  /* We must allocate the symbol in our .dynbss section, which will
+     become part of the .bss section of the executable.  There will be
+     an entry for this symbol in the .dynsym section.  The dynamic
+     object will contain position independent code, so all references
+     from the dynamic object to this symbol will go through the global
+     offset table.  The dynamic linker will use the .dynsym entry to
+     determine the address it must put in the global offset table, so
+     both the dynamic object and the regular object will refer to the
+     same memory location for the variable.  */
+
+  htab = sh_elf_hash_table (info);
+  s = htab->sdynbss;
+  BFD_ASSERT (s != NULL);
+
+  /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
+     copy the initial value out of the dynamic object and into the
+     runtime process image.  We need to remember the offset into the
+     .rela.bss section we are going to use.  */
+  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
+    {
+      asection *srel;
+
+      srel = htab->srelbss;
+      BFD_ASSERT (srel != NULL);
+      srel->_raw_size += sizeof (Elf32_External_Rela);
+      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
+    }
+
+  /* We need to figure out the alignment required for this symbol.  I
+     have no idea how ELF linkers handle this.  */
+  power_of_two = bfd_log2 (h->size);
+  if (power_of_two > 3)
+    power_of_two = 3;
+
+  /* Apply the required alignment.  */
+  s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
+  if (power_of_two > bfd_get_section_alignment (dynobj, s))
+    {
+      if (! bfd_set_section_alignment (dynobj, s, power_of_two))
+	return false;
+    }
+
+  /* Define the symbol as being at this point in the section.  */
+  h->root.u.def.section = s;
+  h->root.u.def.value = s->_raw_size;
+
+  /* Increment the section size to make room for the symbol.  */
+  s->_raw_size += h->size;
+
+  return true;
+}
+
+/* This is the condition under which sh_elf_finish_dynamic_symbol
+   will be called from elflink.h.  If elflink.h doesn't call our
+   finish_dynamic_symbol routine, we'll need to do something about
+   initializing any .plt and .got entries in sh_elf_relocate_section.  */
+#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
+  ((DYN)								\
+   && ((INFO)->shared							\
+       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)	\
+   && ((H)->dynindx != -1						\
+       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
+
+/* Allocate space in .plt, .got and associated reloc sections for
+   dynamic relocs.  */
+
+static boolean
+allocate_dynrelocs (h, inf)
+     struct elf_link_hash_entry *h;
+     PTR inf;
+{
+  struct bfd_link_info *info;
+  struct elf_sh_link_hash_table *htab;
+  struct elf_sh_link_hash_entry *eh;
+  struct elf_sh_dyn_relocs *p;
+
+  if (h->root.type == bfd_link_hash_indirect)
+    return true;
+
+  if (h->root.type == bfd_link_hash_warning)
+    /* When warning symbols are created, they **replace** the "real"
+       entry in the hash table, thus we never get to see the real
+       symbol in a hash traversal.  So look at it now.  */
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+  info = (struct bfd_link_info *) inf;
+  htab = sh_elf_hash_table (info);
+
+  eh = (struct elf_sh_link_hash_entry *) h;
+  if ((h->got.refcount > 0
+      || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
+      && eh->gotplt_refcount > 0)
+    {
+      /* The symbol has been forced local, or we have some direct got refs,
+         so treat all the gotplt refs as got refs. */
+      h->got.refcount += eh->gotplt_refcount;
+      if (h->plt.refcount >= eh->gotplt_refcount)
+	h->plt.refcount -= eh->gotplt_refcount;
+    }
+
+  if (htab->root.dynamic_sections_created
+      && h->plt.refcount > 0)
+    {
+      /* Make sure this symbol is output as a dynamic symbol.
+	 Undefined weak syms won't yet be marked as dynamic.  */
+      if (h->dynindx == -1
+	  && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+	{
+	  if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+	    return false;
+	}
+
+      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
+	{
+	  asection *s = htab->splt;
+
+	  /* If this is the first .plt entry, make room for the special
+	     first entry.  */
+	  if (s->_raw_size == 0)
+	    s->_raw_size += PLT_ENTRY_SIZE;
+
+	  h->plt.offset = s->_raw_size;
+
+	  /* If this symbol is not defined in a regular file, and we are
+	     not generating a shared library, then set the symbol to this
+	     location in the .plt.  This is required to make function
+	     pointers compare as equal between the normal executable and
+	     the shared library.  */
+	  if (! info->shared
+	      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+	    {
+	      h->root.u.def.section = s;
+	      h->root.u.def.value = h->plt.offset;
+	    }
+
+	  /* Make room for this entry.  */
+	  s->_raw_size += PLT_ENTRY_SIZE;
+
+	  /* We also need to make an entry in the .got.plt section, which
+	     will be placed in the .got section by the linker script.  */
+	  htab->sgotplt->_raw_size += 4;
+
+	  /* We also need to make an entry in the .rel.plt section.  */
+	  htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
+	}
+      else
+	{
+	  h->plt.offset = (bfd_vma) -1;
+	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+	}
+    }
+  else
+    {
+      h->plt.offset = (bfd_vma) -1;
+      h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+    }
+
+  if (h->got.refcount > 0)
+    {
+      asection *s;
+      boolean dyn;
+
+      /* Make sure this symbol is output as a dynamic symbol.
+	 Undefined weak syms won't yet be marked as dynamic.  */
+      if (h->dynindx == -1
+	  && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+	{
+	  if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+	    return false;
+	}
+
+      s = htab->sgot;
+#ifdef INCLUDE_SHMEDIA
+      if (h->type == STT_DATALABEL)
+	{
+	  struct elf_sh_link_hash_entry *hsh;
+
+	  h = (struct elf_link_hash_entry *) h->root.u.i.link;
+	  hsh = (struct elf_sh_link_hash_entry *)h;
+	  hsh->datalabel_got_offset = s->_raw_size;
+	}
+      else
+	h->got.offset = s->_raw_size;
+#else
+      h->got.offset = s->_raw_size;
+#endif
+      s->_raw_size += 4;
+      dyn = htab->root.dynamic_sections_created;
+      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
+	htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
+    }
+  else
+    h->got.offset = (bfd_vma) -1;
+
+  if (eh->dyn_relocs == NULL)
+    return true;
+
+  /* In the shared -Bsymbolic case, discard space allocated for
+     dynamic pc-relative relocs against symbols which turn out to be
+     defined in regular objects.  For the normal shared case, discard
+     space for pc-relative relocs that have become local due to symbol
+     visibility changes.  */
+
+  if (info->shared)
+    {
+      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
+	  && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
+	      || info->symbolic))
+	{
+	  struct elf_sh_dyn_relocs **pp;
+
+	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
+	    {
+	      p->count -= p->pc_count;
+	      p->pc_count = 0;
+	      if (p->count == 0)
+		*pp = p->next;
+	      else
+		pp = &p->next;
+	    }
+	}
+    }
+  else
+    {
+      /* For the non-shared case, discard space for relocs against
+	 symbols which turn out to need copy relocs or are not
+	 dynamic.  */
+
+      if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
+	  && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
+	       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+	      || (htab->root.dynamic_sections_created
+		  && (h->root.type == bfd_link_hash_undefweak
+		      || h->root.type == bfd_link_hash_undefined))))
+	{
+	  /* Make sure this symbol is output as a dynamic symbol.
+	     Undefined weak syms won't yet be marked as dynamic.  */
+	  if (h->dynindx == -1
+	      && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+	    {
+	      if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+		return false;
+	    }
+
+	  /* If that succeeded, we know we'll be keeping all the
+	     relocs.  */
+	  if (h->dynindx != -1)
+	    goto keep;
+	}
+
+      eh->dyn_relocs = NULL;
+
+    keep: ;
+    }
+
+  /* Finally, allocate space.  */
+  for (p = eh->dyn_relocs; p != NULL; p = p->next)
+    {
+      asection *sreloc = elf_section_data (p->sec)->sreloc;
+      sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
+    }
+
+  return true;
+}
+
+/* Find any dynamic relocs that apply to read-only sections.  */
+
+static boolean
+readonly_dynrelocs (h, inf)
+     struct elf_link_hash_entry *h;
+     PTR inf;
+{
+  struct elf_sh_link_hash_entry *eh;
+  struct elf_sh_dyn_relocs *p;
+
+  if (h->root.type == bfd_link_hash_warning)
+    h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+  eh = (struct elf_sh_link_hash_entry *) h;
+  for (p = eh->dyn_relocs; p != NULL; p = p->next)
+    {
+      asection *s = p->sec->output_section;
+
+      if (s != NULL && (s->flags & SEC_READONLY) != 0)
+	{
+	  struct bfd_link_info *info = (struct bfd_link_info *) inf;
+
+	  info->flags |= DF_TEXTREL;
+
+	  /* Not an error, just cut short the traversal.  */
+	  return false;
+	}
+    }
+  return true;
+}
+
+/* Set the sizes of the dynamic sections.  */
+
+static boolean
+sh_elf_size_dynamic_sections (output_bfd, info)
+     bfd *output_bfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *info;
+{
+  struct elf_sh_link_hash_table *htab;
+  bfd *dynobj;
+  asection *s;
+  boolean relocs;
+  bfd *ibfd;
+
+  htab = sh_elf_hash_table (info);
+  dynobj = htab->root.dynobj;
+  BFD_ASSERT (dynobj != NULL);
+
+  if (htab->root.dynamic_sections_created)
+    {
+      /* Set the contents of the .interp section to the interpreter.  */
+      if (! info->shared)
+	{
+	  s = bfd_get_section_by_name (dynobj, ".interp");
+	  BFD_ASSERT (s != NULL);
+	  s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
+	  s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
+	}
+    }
+
+  /* Set up .got offsets for local syms, and space for local dynamic
+     relocs.  */
+  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+    {
+      bfd_signed_vma *local_got;
+      bfd_signed_vma *end_local_got;
+      bfd_size_type locsymcount;
+      Elf_Internal_Shdr *symtab_hdr;
+      asection *srel;
+
+      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
+	continue;
+
+      for (s = ibfd->sections; s != NULL; s = s->next)
+	{
+	  struct elf_sh_dyn_relocs *p;
+
+	  for (p = ((struct elf_sh_dyn_relocs *)
+		    elf_section_data (s)->local_dynrel);
+	       p != NULL;
+	       p = p->next)
+	    {
+	      if (! bfd_is_abs_section (p->sec)
+		  && bfd_is_abs_section (p->sec->output_section))
+		{
+		  /* Input section has been discarded, either because
+		     it is a copy of a linkonce section or due to
+		     linker script /DISCARD/, so we'll be discarding
+		     the relocs too.  */
+		}
+	      else if (p->count != 0)
+		{
+		  srel = elf_section_data (p->sec)->sreloc;
+		  srel->_raw_size += p->count * sizeof (Elf32_External_Rela);
+		  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
+		    info->flags |= DF_TEXTREL;
+		}
+	    }
+	}
+
+      local_got = elf_local_got_refcounts (ibfd);
+      if (!local_got)
+	continue;
+
+      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+      locsymcount = symtab_hdr->sh_info;
+#ifdef INCLUDE_SHMEDIA
+      /* Count datalabel local GOT.  */
+      locsymcount *= 2;
+#endif
+      end_local_got = local_got + locsymcount;
+      s = htab->sgot;
+      srel = htab->srelgot;
+      for (; local_got < end_local_got; ++local_got)
+	{
+	  if (*local_got > 0)
+	    {
+	      *local_got = s->_raw_size;
+	      s->_raw_size += 4;
+	      if (info->shared)
+		srel->_raw_size += sizeof (Elf32_External_Rela);
+	    }
+	  else
+	    *local_got = (bfd_vma) -1;
+	}
+    }
+
+  /* Allocate global sym .plt and .got entries, and space for global
+     sym dynamic relocs.  */
+  elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
+
+  /* We now have determined the sizes of the various dynamic sections.
+     Allocate memory for them.  */
+  relocs = false;
+  for (s = dynobj->sections; s != NULL; s = s->next)
+    {
+      if ((s->flags & SEC_LINKER_CREATED) == 0)
+	continue;
+
+      if (s == htab->splt
+	  || s == htab->sgot
+	  || s == htab->sgotplt)
+	{
+	  /* Strip this section if we don't need it; see the
+	     comment below.  */
+	}
+      else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
+	{
+	  if (s->_raw_size != 0 && s != htab->srelplt)
+	    relocs = true;
+
+	  /* We use the reloc_count field as a counter if we need
+	     to copy relocs into the output file.  */
+	  s->reloc_count = 0;
+	}
+      else
+	{
+	  /* It's not one of our sections, so don't allocate space.  */
+	  continue;
+	}
+
+      if (s->_raw_size == 0)
+	{
+	  /* If we don't need this section, strip it from the
+	     output file.  This is mostly to handle .rela.bss and
+	     .rela.plt.  We must create both sections in
+	     create_dynamic_sections, because they must be created
+	     before the linker maps input sections to output
+	     sections.  The linker does that before
+	     adjust_dynamic_symbol is called, and it is that
+	     function which decides whether anything needs to go
+	     into these sections.  */
+
+	  _bfd_strip_section_from_output (info, s);
+	  continue;
+	}
+
+      /* Allocate memory for the section contents.  We use bfd_zalloc
+	 here in case unused entries are not reclaimed before the
+	 section's contents are written out.  This should not happen,
+	 but this way if it does, we get a R_SH_NONE reloc instead
+	 of garbage.  */
+      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
+      if (s->contents == NULL)
+	return false;
+    }
+
+  if (htab->root.dynamic_sections_created)
+    {
+      /* Add some entries to the .dynamic section.  We fill in the
+	 values later, in sh_elf_finish_dynamic_sections, but we
+	 must add the entries now so that we get the correct size for
+	 the .dynamic section.  The DT_DEBUG entry is filled in by the
+	 dynamic linker and used by the debugger.  */
+#define add_dynamic_entry(TAG, VAL) \
+  bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
+
+      if (! info->shared)
+	{
+	  if (! add_dynamic_entry (DT_DEBUG, 0))
+	    return false;
+	}
+
+      if (htab->splt->_raw_size != 0)
+	{
+	  if (! add_dynamic_entry (DT_PLTGOT, 0)
+	      || ! add_dynamic_entry (DT_PLTRELSZ, 0)
+	      || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
+	      || ! add_dynamic_entry (DT_JMPREL, 0))
+	    return false;
+	}
+
+      if (relocs)
+	{
+	  if (! add_dynamic_entry (DT_RELA, 0)
+	      || ! add_dynamic_entry (DT_RELASZ, 0)
+	      || ! add_dynamic_entry (DT_RELAENT,
+				      sizeof (Elf32_External_Rela)))
+	    return false;
+
+	  /* If any dynamic relocs apply to a read-only section,
+	     then we need a DT_TEXTREL entry.  */
+	  if ((info->flags & DF_TEXTREL) == 0)
+	    elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
+				    (PTR) info);
+
+	  if ((info->flags & DF_TEXTREL) != 0)
+	    {
+	      if (! add_dynamic_entry (DT_TEXTREL, 0))
+		return false;
+	    }
+	}
+    }
+#undef add_dynamic_entry
+
+  return true;
+}
+
+/* Relocate an SH ELF section.  */
+
+static boolean
+sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
+			 contents, relocs, local_syms, local_sections)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+     bfd *input_bfd;
+     asection *input_section;
+     bfd_byte *contents;
+     Elf_Internal_Rela *relocs;
+     Elf_Internal_Sym *local_syms;
+     asection **local_sections;
+{
+  struct elf_sh_link_hash_table *htab;
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  Elf_Internal_Rela *rel, *relend;
+  bfd *dynobj;
+  bfd_vma *local_got_offsets;
+  asection *sgot;
+  asection *sgotplt;
+  asection *splt;
+  asection *sreloc;
+
+  htab = sh_elf_hash_table (info);
+  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (input_bfd);
+  dynobj = htab->root.dynobj;
+  local_got_offsets = elf_local_got_offsets (input_bfd);
+
+  sgot = htab->sgot;
+  sgotplt = htab->sgotplt;
+  splt = htab->splt;
+  sreloc = NULL;
+
+  rel = relocs;
+  relend = relocs + input_section->reloc_count;
+  for (; rel < relend; rel++)
+    {
+      int r_type;
+      reloc_howto_type *howto;
+      unsigned long r_symndx;
+      Elf_Internal_Sym *sym;
+      asection *sec;
+      struct elf_link_hash_entry *h;
+      bfd_vma relocation;
+      bfd_vma addend = (bfd_vma) 0;
+      bfd_reloc_status_type r;
+      int seen_stt_datalabel = 0;
+
+      r_symndx = ELF32_R_SYM (rel->r_info);
+
+      r_type = ELF32_R_TYPE (rel->r_info);
+
+      /* Many of the relocs are only used for relaxing, and are
+	 handled entirely by the relaxation code.  */
+      if (r_type > (int) R_SH_LAST_INVALID_RELOC
+	  && r_type < (int) R_SH_LOOP_START)
+	continue;
+      if (r_type == (int) R_SH_NONE)
+	continue;
+
+      if (r_type < 0
+	  || r_type >= R_SH_max
+	  || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
+	      && r_type <= (int) R_SH_LAST_INVALID_RELOC)
+	  || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_3
+	      && r_type <= (int) R_SH_LAST_INVALID_RELOC_3)
+	  || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
+	      && r_type <= (int) R_SH_LAST_INVALID_RELOC_4)
+	  || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
+	      && r_type <= (int) R_SH_LAST_INVALID_RELOC_2))
+	{
+	  bfd_set_error (bfd_error_bad_value);
+	  return false;
+	}
+
+      howto = sh_elf_howto_table + r_type;
+
+      /* For relocs that aren't partial_inplace, we get the addend from
+	 the relocation.  */
+      if (! howto->partial_inplace)
+	addend = rel->r_addend;
+
+      h = NULL;
+      sym = NULL;
+      sec = NULL;
+      if (r_symndx < symtab_hdr->sh_info)
+	{
+	  sym = local_syms + r_symndx;
+	  sec = local_sections[r_symndx];
+	  relocation = (sec->output_section->vma
+			+ sec->output_offset
+			+ sym->st_value);
+	  /* A local symbol never has STO_SH5_ISA32, so we don't need
+	     datalabel processing here.  Make sure this does not change
+	     without notice.  */
+	  if ((sym->st_other & STO_SH5_ISA32) != 0)
+	    ((*info->callbacks->reloc_dangerous)
+	     (info,
+	      _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
+	      input_bfd, input_section, rel->r_offset));
+	  if (info->relocateable)
+	    {
+	      /* This is a relocateable link.  We don't have to change
+		 anything, unless the reloc is against a section symbol,
+		 in which case we have to adjust according to where the
+		 section symbol winds up in the output section.  */
+	      sym = local_syms + r_symndx;
+	      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+		{
+		  if (! howto->partial_inplace)
+		    {
+		      /* For relocations with the addend in the
+			 relocation, we need just to update the addend.
+			 All real relocs are of type partial_inplace; this
+			 code is mostly for completeness.  */
+		      rel->r_addend += sec->output_offset + sym->st_value;
+
+		      continue;
+		    }
+
+		  /* Relocs of type partial_inplace need to pick up the
+		     contents in the contents and add the offset resulting
+		     from the changed location of the section symbol.
+		     Using _bfd_final_link_relocate (e.g. goto
+		     final_link_relocate) here would be wrong, because
+		     relocations marked pc_relative would get the current
+		     location subtracted, and we must only do that at the
+		     final link.  */
+		  r = _bfd_relocate_contents (howto, input_bfd,
+					      sec->output_offset
+					      + sym->st_value,
+					      contents + rel->r_offset);
+		  goto relocation_done;
+		}
+
+	      continue;
+	    }
+	  else if (! howto->partial_inplace)
+	    {
+	      relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
+	      addend = rel->r_addend;
+	    }
+	  else if ((sec->flags & SEC_MERGE)
+		   && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+	    {
+	      asection *msec;
+
+	      if (howto->rightshift || howto->src_mask != 0xffffffff)
+		{
+		  (*_bfd_error_handler)
+		    (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
+		     bfd_archive_filename (input_bfd),
+		     bfd_get_section_name (input_bfd, input_section),
+		     (long) rel->r_offset, howto->name);
+		  return false;
+		}
+
+	      addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
+	      msec = sec;
+	      addend =
+		_bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
+		- relocation;
+	      addend += msec->output_section->vma + msec->output_offset;
+	      bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
+	      addend = 0;
+	    }
+	}
+      else
+	{
+	  /* Section symbol are never (?) placed in the hash table, so
+	     we can just ignore hash relocations when creating a
+	     relocateable object file.  */
+	  if (info->relocateable)
+	    continue;
+
+	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    {
+#ifdef INCLUDE_SHMEDIA
+	      /* If the reference passes a symbol marked with
+		 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
+		 doesn't count.  */
+	      seen_stt_datalabel |= h->type == STT_DATALABEL;
+#endif
+	      h = (struct elf_link_hash_entry *) h->root.u.i.link;
+	    }
+	  if (h->root.type == bfd_link_hash_defined
+	      || h->root.type == bfd_link_hash_defweak)
+	    {
+	      boolean dyn;
+
+	      dyn = htab->root.dynamic_sections_created;
+	      sec = h->root.u.def.section;
+	      /* In these cases, we don't need the relocation value.
+		 We check specially because in some obscure cases
+		 sec->output_section will be NULL.  */
+	      if (r_type == R_SH_GOTPC
+		  || r_type == R_SH_GOTPC_LOW16
+		  || r_type == R_SH_GOTPC_MEDLOW16
+		  || r_type == R_SH_GOTPC_MEDHI16
+		  || r_type == R_SH_GOTPC_HI16
+		  || ((r_type == R_SH_PLT32
+		       || r_type == R_SH_PLT_LOW16
+		       || r_type == R_SH_PLT_MEDLOW16
+		       || r_type == R_SH_PLT_MEDHI16
+		       || r_type == R_SH_PLT_HI16)
+		      && h->plt.offset != (bfd_vma) -1)
+		  || ((r_type == R_SH_GOT32
+		       || r_type == R_SH_GOT_LOW16
+		       || r_type == R_SH_GOT_MEDLOW16
+		       || r_type == R_SH_GOT_MEDHI16
+		       || r_type == R_SH_GOT_HI16)
+		      && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
+		      && (! info->shared
+			  || (! info->symbolic && h->dynindx != -1)
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0))
+		  /* The cases above are those in which relocation is
+		     overwritten in the switch block below.  The cases
+		     below are those in which we must defer relocation
+		     to run-time, because we can't resolve absolute
+		     addresses when creating a shared library.  */
+		  || (info->shared
+		      && ((! info->symbolic && h->dynindx != -1)
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0)
+		      && ((r_type == R_SH_DIR32
+			   && (h->elf_link_hash_flags
+			       & ELF_LINK_FORCED_LOCAL) == 0)
+			  || r_type == R_SH_REL32)
+		      && ((input_section->flags & SEC_ALLOC) != 0
+			  /* DWARF will emit R_SH_DIR32 relocations in its
+			     sections against symbols defined externally
+			     in shared libraries.  We can't do anything
+			     with them here.  */
+			  || ((input_section->flags & SEC_DEBUGGING) != 0
+			      && (h->elf_link_hash_flags
+				  & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
+		relocation = 0;
+	      else if (sec->output_section == NULL)
+		{
+		  (*_bfd_error_handler)
+		    (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
+		     bfd_archive_filename (input_bfd), h->root.root.string,
+		     bfd_get_section_name (input_bfd, input_section));
+		  relocation = 0;
+		}
+	      else
+		relocation = ((h->root.u.def.value
+			      + sec->output_section->vma
+			      + sec->output_offset)
+			      /* A STO_SH5_ISA32 causes a "bitor 1" to the
+				 symbol value, unless we've seen
+				 STT_DATALABEL on the way to it.  */
+			      | ((h->other & STO_SH5_ISA32) != 0
+				 && ! seen_stt_datalabel));
+	    }
+	  else if (h->root.type == bfd_link_hash_undefweak)
+	    relocation = 0;
+	  else if (info->shared
+		   && (! info->symbolic || info->allow_shlib_undefined)
+		   && ! info->no_undefined
+		   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
+	    relocation = 0;
+	  else
+	    {
+	      if (! ((*info->callbacks->undefined_symbol)
+		     (info, h->root.root.string, input_bfd,
+		      input_section, rel->r_offset,
+		      (!info->shared || info->no_undefined
+		       || ELF_ST_VISIBILITY (h->other)))))
+		return false;
+	      relocation = 0;
+	    }
+	}
+
+      switch ((int) r_type)
+	{
+	final_link_relocate:
+	  /* COFF relocs don't use the addend. The addend is used for
+	     R_SH_DIR32 to be compatible with other compilers.  */
+	  r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+					contents, rel->r_offset,
+					relocation, addend);
+	  break;
+
+	case R_SH_IND12W:
+	  relocation -= 4;
+	  goto final_link_relocate;
+
+	case R_SH_DIR8WPN:
+	case R_SH_DIR8WPZ:
+	case R_SH_DIR8WPL:
+	  /* If the reloc is against the start of this section, then
+	     the assembler has already taken care of it and the reloc
+	     is here only to assist in relaxing.  If the reloc is not
+	     against the start of this section, then it's against an
+	     external symbol and we must deal with it ourselves.  */
+	  if (input_section->output_section->vma + input_section->output_offset
+	      != relocation)
+	    {
+	      int disp = (relocation
+			  - input_section->output_section->vma
+			  - input_section->output_offset
+			  - rel->r_offset);
+	      int mask = 0;
+	      switch (r_type)
+		{
+		case R_SH_DIR8WPN:
+		case R_SH_DIR8WPZ: mask = 1; break;
+		case R_SH_DIR8WPL: mask = 3; break;
+		default: mask = 0; break;
+		}
+	      if (disp & mask)
+		{
+		  ((*_bfd_error_handler)
+		   (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
+		    bfd_archive_filename (input_section->owner),
+		    (unsigned long) rel->r_offset));
+		  bfd_set_error (bfd_error_bad_value);
+		  return false;
+		}
+	      relocation -= 4;
+	      goto final_link_relocate;
+	    }
+	  r = bfd_reloc_ok;
+	  break;
+
+	default:
+#ifdef INCLUDE_SHMEDIA
+	  if (shmedia_prepare_reloc (info, input_bfd, input_section,
+				     contents, rel, &relocation))
+	    goto final_link_relocate;
+#endif
+	  bfd_set_error (bfd_error_bad_value);
+	  return false;
+
+	case R_SH_DIR32:
+	case R_SH_REL32:
+	  if (info->shared
+	      && r_symndx != 0
+	      && (input_section->flags & SEC_ALLOC) != 0
+	      && (r_type != R_SH_REL32
+		  || (h != NULL
+		      && h->dynindx != -1
+		      && (! info->symbolic
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0))))
+	    {
+	      Elf_Internal_Rela outrel;
+	      boolean skip, relocate;
+
+	      /* When generating a shared object, these relocations
+		 are copied into the output file to be resolved at run
+		 time.  */
+
+	      if (sreloc == NULL)
+		{
+		  const char *name;
+
+		  name = (bfd_elf_string_from_elf_section
+			  (input_bfd,
+			   elf_elfheader (input_bfd)->e_shstrndx,
+			   elf_section_data (input_section)->rel_hdr.sh_name));
+		  if (name == NULL)
+		    return false;
+
+		  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
+			      && strcmp (bfd_get_section_name (input_bfd,
+							       input_section),
+					 name + 5) == 0);
+
+		  sreloc = bfd_get_section_by_name (dynobj, name);
+		  BFD_ASSERT (sreloc != NULL);
+		}
+
+	      skip = false;
+	      relocate = false;
+
+	      outrel.r_offset =
+		_bfd_elf_section_offset (output_bfd, info, input_section,
+					 rel->r_offset);
+	      if (outrel.r_offset == (bfd_vma) -1)
+		skip = true;
+	      else if (outrel.r_offset == (bfd_vma) -2)
+		skip = true, relocate = true;
+	      outrel.r_offset += (input_section->output_section->vma
+				  + input_section->output_offset);
+
+	      if (skip)
+		memset (&outrel, 0, sizeof outrel);
+	      else if (r_type == R_SH_REL32)
+		{
+		  BFD_ASSERT (h != NULL && h->dynindx != -1);
+		  outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
+		  outrel.r_addend
+		    = bfd_get_32 (input_bfd, contents + rel->r_offset);
+		}
+	      else
+		{
+		  /* h->dynindx may be -1 if this symbol was marked to
+		     become local.  */
+		  if (h == NULL
+		      || ((info->symbolic || h->dynindx == -1)
+			  && (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) != 0))
+		    {
+		      relocate = true;
+		      outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
+		      outrel.r_addend
+			= relocation + bfd_get_32 (input_bfd,
+						   contents + rel->r_offset);
+		    }
+		  else
+		    {
+		      BFD_ASSERT (h->dynindx != -1);
+		      outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
+		      outrel.r_addend
+			= relocation + bfd_get_32 (input_bfd,
+						   contents + rel->r_offset);
+		    }
+		}
+
+	      bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+					 (((Elf32_External_Rela *)
+					   sreloc->contents)
+					  + sreloc->reloc_count));
+	      ++sreloc->reloc_count;
+
+	      /* If this reloc is against an external symbol, we do
+		 not want to fiddle with the addend.  Otherwise, we
+		 need to include the symbol value so that it becomes
+		 an addend for the dynamic reloc.  */
+	      if (! relocate)
+		continue;
+	    }
+	  goto final_link_relocate;
+
+	case R_SH_GOTPLT32:
+#ifdef INCLUDE_SHMEDIA
+	case R_SH_GOTPLT_LOW16:
+	case R_SH_GOTPLT_MEDLOW16:
+	case R_SH_GOTPLT_MEDHI16:
+	case R_SH_GOTPLT_HI16:
+	case R_SH_GOTPLT10BY4:
+	case R_SH_GOTPLT10BY8:
+#endif
+	  /* Relocation is to the entry for this symbol in the
+	     procedure linkage table.  */
+
+	  if (h == NULL
+	      || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
+	      || ! info->shared
+	      || info->symbolic
+	      || h->dynindx == -1
+	      || h->plt.offset == (bfd_vma) -1
+	      || h->got.offset != (bfd_vma) -1)
+	    goto force_got;
+
+	  /* Relocation is to the entry for this symbol in the global
+	     offset table extension for the procedure linkage table.  */
+
+	  BFD_ASSERT (sgotplt != NULL);
+	  relocation = (sgotplt->output_offset
+			+ ((h->plt.offset / elf_sh_sizeof_plt (info)
+			    - 1 + 3) * 4));
+
+#ifdef GOT_BIAS
+	  relocation -= GOT_BIAS;
+#endif
+
+	  goto final_link_relocate;
+
+	force_got:
+	case R_SH_GOT32:
+#ifdef INCLUDE_SHMEDIA
+	case R_SH_GOT_LOW16:
+	case R_SH_GOT_MEDLOW16:
+	case R_SH_GOT_MEDHI16:
+	case R_SH_GOT_HI16:
+	case R_SH_GOT10BY4:
+	case R_SH_GOT10BY8:
+#endif
+	  /* Relocation is to the entry for this symbol in the global
+	     offset table.  */
+
+	  BFD_ASSERT (sgot != NULL);
+
+	  if (h != NULL)
+	    {
+	      bfd_vma off;
+	      boolean dyn;
+
+	      off = h->got.offset;
+#ifdef INCLUDE_SHMEDIA
+	      if (seen_stt_datalabel)
+		{
+		  struct elf_sh_link_hash_entry *hsh;
+
+		  hsh = (struct elf_sh_link_hash_entry *)h;
+		  off = hsh->datalabel_got_offset;
+		}
+#endif
+	      BFD_ASSERT (off != (bfd_vma) -1);
+
+	      dyn = htab->root.dynamic_sections_created;
+	      if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
+		  || (info->shared
+		      && (info->symbolic || h->dynindx == -1
+			  || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
+		      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
+		{
+		  /* This is actually a static link, or it is a
+		     -Bsymbolic link and the symbol is defined
+		     locally, or the symbol was forced to be local
+		     because of a version file.  We must initialize
+		     this entry in the global offset table.  Since the
+		     offset must always be a multiple of 4, we use the
+		     least significant bit to record whether we have
+		     initialized it already.
+
+		     When doing a dynamic link, we create a .rela.got
+		     relocation entry to initialize the value.  This
+		     is done in the finish_dynamic_symbol routine.  */
+		  if ((off & 1) != 0)
+		    off &= ~1;
+		  else
+		    {
+		      bfd_put_32 (output_bfd, relocation,
+				  sgot->contents + off);
+#ifdef INCLUDE_SHMEDIA
+		      if (seen_stt_datalabel)
+			{
+			  struct elf_sh_link_hash_entry *hsh;
+
+			  hsh = (struct elf_sh_link_hash_entry *)h;
+			  hsh->datalabel_got_offset |= 1;
+			}
+		      else
+#endif
+			h->got.offset |= 1;
+		    }
+		}
+
+	      relocation = sgot->output_offset + off;
+	    }
+	  else
+	    {
+	      bfd_vma off;
+
+#ifdef INCLUDE_SHMEDIA
+	      if (rel->r_addend)
+		{
+		  BFD_ASSERT (local_got_offsets != NULL
+			      && (local_got_offsets[symtab_hdr->sh_info
+						    + r_symndx]
+				  != (bfd_vma) -1));
+
+		  off = local_got_offsets[symtab_hdr->sh_info
+					  + r_symndx];
+		}
+	      else
+		{
+#endif
+	      BFD_ASSERT (local_got_offsets != NULL
+			  && local_got_offsets[r_symndx] != (bfd_vma) -1);
+
+	      off = local_got_offsets[r_symndx];
+#ifdef INCLUDE_SHMEDIA
+		}
+#endif
+
+	      /* The offset must always be a multiple of 4.  We use
+		 the least significant bit to record whether we have
+		 already generated the necessary reloc.  */
+	      if ((off & 1) != 0)
+		off &= ~1;
+	      else
+		{
+		  bfd_put_32 (output_bfd, relocation, sgot->contents + off);
+
+		  if (info->shared)
+		    {
+		      asection *srelgot;
+		      Elf_Internal_Rela outrel;
+
+		      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+		      BFD_ASSERT (srelgot != NULL);
+
+		      outrel.r_offset = (sgot->output_section->vma
+					 + sgot->output_offset
+					 + off);
+		      outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
+		      outrel.r_addend = relocation;
+		      bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+						(((Elf32_External_Rela *)
+						  srelgot->contents)
+						 + srelgot->reloc_count));
+		      ++srelgot->reloc_count;
+		    }
+
+#ifdef INCLUDE_SHMEDIA
+		  if (rel->r_addend)
+		    local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
+		  else
+#endif
+		    local_got_offsets[r_symndx] |= 1;
+		}
+
+	      relocation = sgot->output_offset + off;
+	    }
+
+#ifdef GOT_BIAS
+	  relocation -= GOT_BIAS;
+#endif
+
+	  goto final_link_relocate;
+
+	case R_SH_GOTOFF:
+#ifdef INCLUDE_SHMEDIA
+	case R_SH_GOTOFF_LOW16:
+	case R_SH_GOTOFF_MEDLOW16:
+	case R_SH_GOTOFF_MEDHI16:
+	case R_SH_GOTOFF_HI16:
+#endif
+	  /* Relocation is relative to the start of the global offset
+	     table.  */
+
+	  BFD_ASSERT (sgot != NULL);
+
+	  /* Note that sgot->output_offset is not involved in this
+	     calculation.  We always want the start of .got.  If we
+	     defined _GLOBAL_OFFSET_TABLE in a different way, as is
+	     permitted by the ABI, we might have to change this
+	     calculation.  */
+	  relocation -= sgot->output_section->vma;
+
+#ifdef GOT_BIAS
+	  relocation -= GOT_BIAS;
+#endif
+
+	  addend = rel->r_addend;
+
+	  goto final_link_relocate;
+
+	case R_SH_GOTPC:
+#ifdef INCLUDE_SHMEDIA
+	case R_SH_GOTPC_LOW16:
+	case R_SH_GOTPC_MEDLOW16:
+	case R_SH_GOTPC_MEDHI16:
+	case R_SH_GOTPC_HI16:
+#endif
+	  /* Use global offset table as symbol value.  */
+
+	  BFD_ASSERT (sgot != NULL);
+	  relocation = sgot->output_section->vma;
+
+#ifdef GOT_BIAS
+	  relocation += GOT_BIAS;
+#endif
+
+	  addend = rel->r_addend;
+
+	  goto final_link_relocate;
+
+	case R_SH_PLT32:
+#ifdef INCLUDE_SHMEDIA
+	case R_SH_PLT_LOW16:
+	case R_SH_PLT_MEDLOW16:
+	case R_SH_PLT_MEDHI16:
+	case R_SH_PLT_HI16:
+#endif
+	  /* Relocation is to the entry for this symbol in the
+	     procedure linkage table.  */
+
+	  /* Resolve a PLT reloc against a local symbol directly,
+	     without using the procedure linkage table.  */
+	  if (h == NULL)
+	    goto final_link_relocate;
+
+	  if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
+	    goto final_link_relocate;
+
+	  if (h->plt.offset == (bfd_vma) -1)
+	    {
+	      /* We didn't make a PLT entry for this symbol.  This
+		 happens when statically linking PIC code, or when
+		 using -Bsymbolic.  */
+	      goto final_link_relocate;
+	    }
+
+	  BFD_ASSERT (splt != NULL);
+	  relocation = (splt->output_section->vma
+			+ splt->output_offset
+			+ h->plt.offset);
+
+#ifdef INCLUDE_SHMEDIA
+	  relocation++;
+#endif
+
+	  addend = rel->r_addend;
+
+	  goto final_link_relocate;
+
+	case R_SH_LOOP_START:
+	  {
+	    static bfd_vma start, end;
+
+	    start = (relocation + rel->r_addend
+		     - (sec->output_section->vma + sec->output_offset));
+	    r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
+				   rel->r_offset, sec, start, end);
+	    break;
+
+	case R_SH_LOOP_END:
+	    end = (relocation + rel->r_addend
+		   - (sec->output_section->vma + sec->output_offset));
+	    r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
+				   rel->r_offset, sec, start, end);
+	    break;
+	  }
+	}
+
+    relocation_done:
+      if (r != bfd_reloc_ok)
+	{
+	  switch (r)
+	    {
+	    default:
+	    case bfd_reloc_outofrange:
+	      abort ();
+	    case bfd_reloc_overflow:
+	      {
+		const char *name;
+
+		if (h != NULL)
+		  name = h->root.root.string;
+		else
+		  {
+		    name = (bfd_elf_string_from_elf_section
+			    (input_bfd, symtab_hdr->sh_link, sym->st_name));
+		    if (name == NULL)
+		      return false;
+		    if (*name == '\0')
+		      name = bfd_section_name (input_bfd, sec);
+		  }
+		if (! ((*info->callbacks->reloc_overflow)
+		       (info, name, howto->name, (bfd_vma) 0,
+			input_bfd, input_section, rel->r_offset)))
+		  return false;
+	      }
+	      break;
+	    }
+	}
+    }
+
+  return true;
+}
+
+/* This is a version of bfd_generic_get_relocated_section_contents
+   which uses sh_elf_relocate_section.  */
+
+static bfd_byte *
+sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
+				       data, relocateable, symbols)
+     bfd *output_bfd;
+     struct bfd_link_info *link_info;
+     struct bfd_link_order *link_order;
+     bfd_byte *data;
+     boolean relocateable;
+     asymbol **symbols;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  asection *input_section = link_order->u.indirect.section;
+  bfd *input_bfd = input_section->owner;
+  asection **sections = NULL;
+  Elf_Internal_Rela *internal_relocs = NULL;
+  Elf_Internal_Sym *isymbuf = NULL;
+
+  /* We only need to handle the case of relaxing, or of having a
+     particular set of section contents, specially.  */
+  if (relocateable
+      || elf_section_data (input_section)->this_hdr.contents == NULL)
+    return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
+						       link_order, data,
+						       relocateable,
+						       symbols);
+
+  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+
+  memcpy (data, elf_section_data (input_section)->this_hdr.contents,
+	  (size_t) input_section->_raw_size);
+
+  if ((input_section->flags & SEC_RELOC) != 0
+      && input_section->reloc_count > 0)
+    {
+      asection **secpp;
+      Elf_Internal_Sym *isym, *isymend;
+      bfd_size_type amt;
+
+      internal_relocs = (_bfd_elf32_link_read_relocs
+			 (input_bfd, input_section, (PTR) NULL,
+			  (Elf_Internal_Rela *) NULL, false));
+      if (internal_relocs == NULL)
+	goto error_return;
+
+      if (symtab_hdr->sh_info != 0)
+	{
+	  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
+	  if (isymbuf == NULL)
+	    isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
+					    symtab_hdr->sh_info, 0,
+					    NULL, NULL, NULL);
+	  if (isymbuf == NULL)
+	    goto error_return;
+	}
+
+      amt = symtab_hdr->sh_info;
+      amt *= sizeof (asection *);
+      sections = (asection **) bfd_malloc (amt);
+      if (sections == NULL && amt != 0)
+	goto error_return;
+
+      isymend = isymbuf + symtab_hdr->sh_info;
+      for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
+	{
+	  asection *isec;
+
+	  if (isym->st_shndx == SHN_UNDEF)
+	    isec = bfd_und_section_ptr;
+	  else if (isym->st_shndx == SHN_ABS)
+	    isec = bfd_abs_section_ptr;
+	  else if (isym->st_shndx == SHN_COMMON)
+	    isec = bfd_com_section_ptr;
+	  else
+	    isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
+
+	  *secpp = isec;
+	}
+
+      if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
+				     input_section, data, internal_relocs,
+				     isymbuf, sections))
+	goto error_return;
+
+      if (sections != NULL)
+	free (sections);
+      if (isymbuf != NULL
+	  && symtab_hdr->contents != (unsigned char *) isymbuf)
+	free (isymbuf);
+      if (elf_section_data (input_section)->relocs != internal_relocs)
+	free (internal_relocs);
+    }
+
+  return data;
+
+ error_return:
+  if (sections != NULL)
+    free (sections);
+  if (isymbuf != NULL
+      && symtab_hdr->contents != (unsigned char *) isymbuf)
+    free (isymbuf);
+  if (internal_relocs != NULL
+      && elf_section_data (input_section)->relocs != internal_relocs)
+    free (internal_relocs);
+  return NULL;
+}
+
+static asection *
+sh_elf_gc_mark_hook (sec, info, rel, h, sym)
+     asection *sec;
+     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     Elf_Internal_Rela *rel;
+     struct elf_link_hash_entry *h;
+     Elf_Internal_Sym *sym;
+{
+  if (h != NULL)
+    {
+      switch (ELF32_R_TYPE (rel->r_info))
+	{
+	case R_SH_GNU_VTINHERIT:
+	case R_SH_GNU_VTENTRY:
+	  break;
+
+	default:
+	  switch (h->root.type)
+	    {
+	    case bfd_link_hash_defined:
+	    case bfd_link_hash_defweak:
+	      return h->root.u.def.section;
+
+	    case bfd_link_hash_common:
+	      return h->root.u.c.p->section;
+
+	    default:
+	      break;
+	    }
+	}
+    }
+  else
+    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
+
+  return NULL;
+}
+
+/* Update the got entry reference counts for the section being removed.  */
+
+static boolean
+sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  bfd_signed_vma *local_got_refcounts;
+  const Elf_Internal_Rela *rel, *relend;
+  unsigned long r_symndx;
+  struct elf_link_hash_entry *h;
+  struct elf_sh_link_hash_entry *eh;
+
+  elf_section_data (sec)->local_dynrel = NULL;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_refcounts = elf_local_got_refcounts (abfd);
+
+  relend = relocs + sec->reloc_count;
+  for (rel = relocs; rel < relend; rel++)
+    switch (ELF32_R_TYPE (rel->r_info))
+      {
+      case R_SH_GOT32:
+      case R_SH_GOTOFF:
+      case R_SH_GOTPC:
+#ifdef INCLUDE_SHMEDIA
+      case R_SH_GOT_LOW16:
+      case R_SH_GOT_MEDLOW16:
+      case R_SH_GOT_MEDHI16:
+      case R_SH_GOT_HI16:
+      case R_SH_GOT10BY4:
+      case R_SH_GOT10BY8:
+      case R_SH_GOTOFF_LOW16:
+      case R_SH_GOTOFF_MEDLOW16:
+      case R_SH_GOTOFF_MEDHI16:
+      case R_SH_GOTOFF_HI16:
+      case R_SH_GOTPC_LOW16:
+      case R_SH_GOTPC_MEDLOW16:
+      case R_SH_GOTPC_MEDHI16:
+      case R_SH_GOTPC_HI16:
+#endif
+	r_symndx = ELF32_R_SYM (rel->r_info);
+	if (r_symndx >= symtab_hdr->sh_info)
+	  {
+	    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	    if (h->got.refcount > 0)
+	      h->got.refcount -= 1;
+	  }
+	else if (local_got_refcounts != NULL)
+	  {
+	    if (local_got_refcounts[r_symndx] > 0)
+	      local_got_refcounts[r_symndx] -= 1;
+	  }
+	break;
+
+      case R_SH_DIR32:
+      case R_SH_REL32:
+	r_symndx = ELF32_R_SYM (rel->r_info);
+	if (r_symndx >= symtab_hdr->sh_info)
+	  {
+	    struct elf_sh_link_hash_entry *eh;
+	    struct elf_sh_dyn_relocs **pp;
+	    struct elf_sh_dyn_relocs *p;
+
+	    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+
+	    if (!info->shared && h->plt.refcount > 0)
+	      h->plt.refcount -= 1;
+
+	    eh = (struct elf_sh_link_hash_entry *) h;
+
+	    for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
+	      if (p->sec == sec)
+		{
+		  if (ELF32_R_TYPE (rel->r_info) == R_SH_REL32)
+		    p->pc_count -= 1;
+		  p->count -= 1;
+		  if (p->count == 0)
+		    *pp = p->next;
+		  break;
+		}
+	  }
+	break;
+
+      case R_SH_PLT32:
+#ifdef INCLUDE_SHMEDIA
+      case R_SH_PLT_LOW16:
+      case R_SH_PLT_MEDLOW16:
+      case R_SH_PLT_MEDHI16:
+      case R_SH_PLT_HI16:
+#endif
+	r_symndx = ELF32_R_SYM (rel->r_info);
+	if (r_symndx >= symtab_hdr->sh_info)
+	  {
+	    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	    if (h->plt.refcount > 0)
+	      h->plt.refcount -= 1;
+	  }
+	break;
+
+      case R_SH_GOTPLT32:
+#ifdef INCLUDE_SHMEDIA
+      case R_SH_GOTPLT_LOW16:
+      case R_SH_GOTPLT_MEDLOW16:
+      case R_SH_GOTPLT_MEDHI16:
+      case R_SH_GOTPLT_HI16:
+      case R_SH_GOTPLT10BY4:
+      case R_SH_GOTPLT10BY8:
+#endif
+	r_symndx = ELF32_R_SYM (rel->r_info);
+	if (r_symndx >= symtab_hdr->sh_info)
+	  {
+	    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	    eh = (struct elf_sh_link_hash_entry *) h;
+	    if (eh->gotplt_refcount > 0)
+	      {
+		eh->gotplt_refcount -= 1;
+		if (h->plt.refcount > 0)
+		  h->plt.refcount -= 1;
+	      }
+	    else if (h->got.refcount > 0)
+	      h->got.refcount -= 1;
+	  }
+	else if (local_got_refcounts != NULL)
+	  {
+	    if (local_got_refcounts[r_symndx] > 0)
+	      local_got_refcounts[r_symndx] -= 1;
+	  }
+	break;
+
+      default:
+	break;
+      }
+
+  return true;
+}
+
+/* Copy the extra info we tack onto an elf_link_hash_entry.  */
+
+static void
+sh_elf_copy_indirect_symbol (bed, dir, ind)
+     struct elf_backend_data *bed;
+     struct elf_link_hash_entry *dir, *ind;
+{
+  struct elf_sh_link_hash_entry *edir, *eind;
+
+  edir = (struct elf_sh_link_hash_entry *) dir;
+  eind = (struct elf_sh_link_hash_entry *) ind;
+
+  if (eind->dyn_relocs != NULL)
+    {
+      if (edir->dyn_relocs != NULL)
+	{
+	  struct elf_sh_dyn_relocs **pp;
+	  struct elf_sh_dyn_relocs *p;
+
+	  BFD_ASSERT (ind->root.type != bfd_link_hash_indirect);
+
+	  /* Add reloc counts against the weak sym to the strong sym
+	     list.  Merge any entries against the same section.  */
+	  for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
+	    {
+	      struct elf_sh_dyn_relocs *q;
+
+	      for (q = edir->dyn_relocs; q != NULL; q = q->next)
+		if (q->sec == p->sec)
+		  {
+		    q->pc_count += p->pc_count;
+		    q->count += p->count;
+		    *pp = p->next;
+		    break;
+		  }
+	      if (q == NULL)
+		pp = &p->next;
+	    }
+	  *pp = edir->dyn_relocs;
+	}
+
+      edir->dyn_relocs = eind->dyn_relocs;
+      eind->dyn_relocs = NULL;
+    }
+  edir->gotplt_refcount = eind->gotplt_refcount;
+  eind->gotplt_refcount = 0;
+
+  _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
+}
+
+/* Look through the relocs for a section during the first phase.
+   Since we don't do .gots or .plts, we just need to consider the
+   virtual table relocs for gc.  */
+
+static boolean
+sh_elf_check_relocs (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
+  struct elf_sh_link_hash_table *htab;
+  const Elf_Internal_Rela *rel;
+  const Elf_Internal_Rela *rel_end;
+  bfd *dynobj;
+  bfd_vma *local_got_offsets;
+  asection *sgot;
+  asection *srelgot;
+  asection *sreloc;
+
+  sgot = NULL;
+  srelgot = NULL;
+  sreloc = NULL;
+
+  if (info->relocateable)
+    return true;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
+  if (!elf_bad_symtab (abfd))
+    sym_hashes_end -= symtab_hdr->sh_info;
+
+  htab = sh_elf_hash_table (info);
+  dynobj = htab->root.dynobj;
+  local_got_offsets = elf_local_got_offsets (abfd);
+
+  rel_end = relocs + sec->reloc_count;
+  for (rel = relocs; rel < rel_end; rel++)
+    {
+      struct elf_link_hash_entry *h;
+      unsigned long r_symndx;
+
+      r_symndx = ELF32_R_SYM (rel->r_info);
+      if (r_symndx < symtab_hdr->sh_info)
+	h = NULL;
+      else
+	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+
+      /* Some relocs require a global offset table.  */
+      if (htab->sgot == NULL)
+	{
+	  switch (ELF32_R_TYPE (rel->r_info))
+	    {
+	    case R_SH_GOTPLT32:
+	    case R_SH_GOT32:
+	    case R_SH_GOTOFF:
+	    case R_SH_GOTPC:
+#ifdef INCLUDE_SHMEDIA
+	    case R_SH_GOTPLT_LOW16:
+	    case R_SH_GOTPLT_MEDLOW16:
+	    case R_SH_GOTPLT_MEDHI16:
+	    case R_SH_GOTPLT_HI16:
+	    case R_SH_GOTPLT10BY4:
+	    case R_SH_GOTPLT10BY8:
+	    case R_SH_GOT_LOW16:
+	    case R_SH_GOT_MEDLOW16:
+	    case R_SH_GOT_MEDHI16:
+	    case R_SH_GOT_HI16:
+	    case R_SH_GOT10BY4:
+	    case R_SH_GOT10BY8:
+	    case R_SH_GOTOFF_LOW16:
+	    case R_SH_GOTOFF_MEDLOW16:
+	    case R_SH_GOTOFF_MEDHI16:
+	    case R_SH_GOTOFF_HI16:
+	    case R_SH_GOTPC_LOW16:
+	    case R_SH_GOTPC_MEDLOW16:
+	    case R_SH_GOTPC_MEDHI16:
+	    case R_SH_GOTPC_HI16:
+#endif
+	      if (dynobj == NULL)
+		htab->root.dynobj = dynobj = abfd;
+	      if (! create_got_section (dynobj, info))
+		return false;
+	      break;
+
+	    default:
+	      break;
+	    }
+	}
+
+      switch (ELF32_R_TYPE (rel->r_info))
+	{
+	  /* This relocation describes the C++ object vtable hierarchy.
+	     Reconstruct it for later use during GC.  */
+	case R_SH_GNU_VTINHERIT:
+	  if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
+	    return false;
+	  break;
+
+	  /* This relocation describes which C++ vtable entries are actually
+	     used.  Record for later use during GC.  */
+	case R_SH_GNU_VTENTRY:
+	  if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+	    return false;
+	  break;
+
+	force_got:
+	case R_SH_GOT32:
+#ifdef INCLUDE_SHMEDIA
+	case R_SH_GOT_LOW16:
+	case R_SH_GOT_MEDLOW16:
+	case R_SH_GOT_MEDHI16:
+	case R_SH_GOT_HI16:
+	case R_SH_GOT10BY4:
+	case R_SH_GOT10BY8:
+#endif
+	  if (h != NULL)
+	    h->got.refcount += 1;
+	  else
+	    {
+	      bfd_signed_vma *local_got_refcounts;
+
+	      /* This is a global offset table entry for a local
+		 symbol.  */
+	      local_got_refcounts = elf_local_got_refcounts (abfd);
+	      if (local_got_refcounts == NULL)
+		{
+		  bfd_size_type size;
+
+		  size = symtab_hdr->sh_info;
+		  size *= sizeof (bfd_signed_vma);
+#ifdef INCLUDE_SHMEDIA
+		  /* Reserve space for both the datalabel and
+		     codelabel local GOT offsets.  */
+		  size *= 2;
+#endif
+		  local_got_refcounts = ((bfd_signed_vma *)
+					 bfd_zalloc (abfd, size));
+		  if (local_got_refcounts == NULL)
+		    return false;
+		  elf_local_got_refcounts (abfd) = local_got_refcounts;
+		}
+	      local_got_refcounts[r_symndx] += 1;
+	    }
+	  break;
+
+	case R_SH_GOTPLT32:
+#ifdef INCLUDE_SHMEDIA
+	case R_SH_GOTPLT_LOW16:
+	case R_SH_GOTPLT_MEDLOW16:
+	case R_SH_GOTPLT_MEDHI16:
+	case R_SH_GOTPLT_HI16:
+	case R_SH_GOTPLT10BY4:
+	case R_SH_GOTPLT10BY8:
+#endif
+	  /* If this is a local symbol, we resolve it directly without
+	     creating a procedure linkage table entry.  */
+
+	  if (h == NULL
+	      || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
+	      || ! info->shared
+	      || info->symbolic
+	      || h->dynindx == -1)
+	    goto force_got;
+
+	  h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	  h->plt.refcount += 1;
+	  ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
+
+	  break;
+
+	case R_SH_PLT32:
+#ifdef INCLUDE_SHMEDIA
+	case R_SH_PLT_LOW16:
+	case R_SH_PLT_MEDLOW16:
+	case R_SH_PLT_MEDHI16:
+	case R_SH_PLT_HI16:
+#endif
+	  /* This symbol requires a procedure linkage table entry.  We
+	     actually build the entry in adjust_dynamic_symbol,
+	     because this might be a case of linking PIC code which is
+	     never referenced by a dynamic object, in which case we
+	     don't need to generate a procedure linkage table entry
+	     after all.  */
+
+	  /* If this is a local symbol, we resolve it directly without
+	     creating a procedure linkage table entry.  */
+	  if (h == NULL)
+	    continue;
+
+	  if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
+	    break;
+
+	  h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	  h->plt.refcount += 1;
+	  break;
+
+	case R_SH_DIR32:
+	case R_SH_REL32:
+	  if (h != NULL && ! info->shared)
+	    {
+	      h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+	      h->plt.refcount += 1;
+	    }
+
+	  /* If we are creating a shared library, and this is a reloc
+	     against a global symbol, or a non PC relative reloc
+	     against a local symbol, then we need to copy the reloc
+	     into the shared library.  However, if we are linking with
+	     -Bsymbolic, we do not need to copy a reloc against a
+	     global symbol which is defined in an object we are
+	     including in the link (i.e., DEF_REGULAR is set).  At
+	     this point we have not seen all the input files, so it is
+	     possible that DEF_REGULAR is not set now but will be set
+	     later (it is never cleared).  We account for that
+	     possibility below by storing information in the
+	     dyn_relocs field of the hash table entry. A similar
+	     situation occurs when creating shared libraries and symbol
+	     visibility changes render the symbol local.
+
+	     If on the other hand, we are creating an executable, we
+	     may need to keep relocations for symbols satisfied by a
+	     dynamic library if we manage to avoid copy relocs for the
+	     symbol.  */
+	  if ((info->shared
+	       && (sec->flags & SEC_ALLOC) != 0
+	       && (ELF32_R_TYPE (rel->r_info) != R_SH_REL32
+		   || (h != NULL
+		       && (! info->symbolic
+			   || h->root.type == bfd_link_hash_defweak
+			   || (h->elf_link_hash_flags
+			       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
+	      || (! info->shared
+		  && (sec->flags & SEC_ALLOC) != 0
+		  && h != NULL
+		  && (h->root.type == bfd_link_hash_defweak
+		      || (h->elf_link_hash_flags
+			  & ELF_LINK_HASH_DEF_REGULAR) == 0)))
+	    {
+	      struct elf_sh_dyn_relocs *p;
+	      struct elf_sh_dyn_relocs **head;
+
+	      if (dynobj == NULL)
+		htab->root.dynobj = dynobj = abfd;
+
+	      /* When creating a shared object, we must copy these
+		 reloc types into the output file.  We create a reloc
+		 section in dynobj and make room for this reloc.  */
+	      if (sreloc == NULL)
+		{
+		  const char *name;
+
+		  name = (bfd_elf_string_from_elf_section
+			  (abfd,
+			   elf_elfheader (abfd)->e_shstrndx,
+			   elf_section_data (sec)->rel_hdr.sh_name));
+		  if (name == NULL)
+		    return false;
+
+		  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
+			      && strcmp (bfd_get_section_name (abfd, sec),
+					 name + 5) == 0);
+
+		  sreloc = bfd_get_section_by_name (dynobj, name);
+		  if (sreloc == NULL)
+		    {
+		      flagword flags;
+
+		      sreloc = bfd_make_section (dynobj, name);
+		      flags = (SEC_HAS_CONTENTS | SEC_READONLY
+			       | SEC_IN_MEMORY | SEC_LINKER_CREATED);
+		      if ((sec->flags & SEC_ALLOC) != 0)
+			flags |= SEC_ALLOC | SEC_LOAD;
+		      if (sreloc == NULL
+			  || ! bfd_set_section_flags (dynobj, sreloc, flags)
+			  || ! bfd_set_section_alignment (dynobj, sreloc, 2))
+			return false;
+		    }
+		  if (sec->flags & SEC_READONLY)
+		    info->flags |= DF_TEXTREL;
+		  elf_section_data (sec)->sreloc = sreloc;
+		}
+
+	      /* If this is a global symbol, we count the number of
+		 relocations we need for this symbol.  */
+	      if (h != NULL)
+		head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
+	      else
+		{
+		  asection *s;
+
+		  /* Track dynamic relocs needed for local syms too.  */
+		  s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
+						 sec, r_symndx);
+		  if (s == NULL)
+		    return false;
+
+		  head = ((struct elf_sh_dyn_relocs **)
+			  &elf_section_data (s)->local_dynrel);
+		}
+
+	      p = *head;
+	      if (p == NULL || p->sec != sec)
+		{
+		  bfd_size_type amt = sizeof (*p);
+		  p = ((struct elf_sh_dyn_relocs *) bfd_alloc (dynobj, amt));
+		  if (p == NULL)
+		    return false;
+		  p->next = *head;
+		  *head = p;
+		  p->sec = sec;
+		  p->count = 0;
+		  p->pc_count = 0;
+		}
+
+	      p->count += 1;
+	      if (ELF32_R_TYPE (rel->r_info) == R_SH_REL32)
+		p->pc_count += 1;
+	    }
+
+	  break;
+	}
+    }
+
+  return true;
+}
+
+#ifndef sh_elf_set_mach_from_flags
+static boolean
+sh_elf_set_mach_from_flags (abfd)
+     bfd *abfd;
+{
+  flagword flags = elf_elfheader (abfd)->e_flags;
+
+  switch (flags & EF_SH_MACH_MASK)
+    {
+    case EF_SH1:
+      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
+      break;
+    case EF_SH2:
+      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
+      break;
+    case EF_SH_DSP:
+      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
+      break;
+    case EF_SH3:
+      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
+      break;
+    case EF_SH3_DSP:
+      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
+      break;
+    case EF_SH3E:
+      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
+      break;
+    case EF_SH_UNKNOWN:
+    case EF_SH4:
+      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
+      break;
+    default:
+      return false;
+    }
+  return true;
+}
+#endif /* not sh_elf_set_mach_from_flags */
+
+#ifndef sh_elf_set_private_flags
+/* Function to keep SH specific file flags.  */
+
+static boolean
+sh_elf_set_private_flags (abfd, flags)
+     bfd *abfd;
+     flagword flags;
+{
+  BFD_ASSERT (! elf_flags_init (abfd)
+	      || elf_elfheader (abfd)->e_flags == flags);
+
+  elf_elfheader (abfd)->e_flags = flags;
+  elf_flags_init (abfd) = true;
+  return sh_elf_set_mach_from_flags (abfd);
+}
+#endif /* not sh_elf_set_private_flags */
+
+#ifndef sh_elf_copy_private_data
+/* Copy backend specific data from one object module to another */
+
+static boolean
+sh_elf_copy_private_data (ibfd, obfd)
+     bfd * ibfd;
+     bfd * obfd;
+{
+  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
+      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
+    return true;
+
+  return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
+}
+#endif /* not sh_elf_copy_private_data */
+
+#ifndef sh_elf_merge_private_data
+/* This routine checks for linking big and little endian objects
+   together, and for linking sh-dsp with sh3e / sh4 objects.  */
+
+static boolean
+sh_elf_merge_private_data (ibfd, obfd)
+     bfd *ibfd;
+     bfd *obfd;
+{
+  flagword old_flags, new_flags;
+
+  if (! _bfd_generic_verify_endian_match (ibfd, obfd))
+    return false;
+
+  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
+      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
+    return true;
+
+  if (! elf_flags_init (obfd))
+    {
+      /* This happens when ld starts out with a 'blank' output file.  */
+      elf_flags_init (obfd) = true;
+      elf_elfheader (obfd)->e_flags = EF_SH1;
+    }
+  old_flags = elf_elfheader (obfd)->e_flags;
+  new_flags = elf_elfheader (ibfd)->e_flags;
+  if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
+      || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
+    {
+      (*_bfd_error_handler)
+	("%s: uses %s instructions while previous modules use %s instructions",
+	 bfd_archive_filename (ibfd),
+	 EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
+	 EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
+      bfd_set_error (bfd_error_bad_value);
+      return false;
+    }
+  elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
+
+  return sh_elf_set_mach_from_flags (obfd);
+}
+#endif /* not sh_elf_merge_private_data */
+
+/* Finish up dynamic symbol handling.  We set the contents of various
+   dynamic sections here.  */
+
+static boolean
+sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+     struct elf_link_hash_entry *h;
+     Elf_Internal_Sym *sym;
+{
+  struct elf_sh_link_hash_table *htab;
+  bfd *dynobj;
+
+  htab = sh_elf_hash_table (info);
+  dynobj = htab->root.dynobj;
+
+  if (h->plt.offset != (bfd_vma) -1)
+    {
+      asection *splt;
+      asection *sgot;
+      asection *srel;
+
+      bfd_vma plt_index;
+      bfd_vma got_offset;
+      Elf_Internal_Rela rel;
+
+      /* This symbol has an entry in the procedure linkage table.  Set
+	 it up.  */
+
+      BFD_ASSERT (h->dynindx != -1);
+
+      splt = htab->splt;
+      sgot = htab->sgotplt;
+      srel = htab->srelplt;
+      BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
+
+      /* Get the index in the procedure linkage table which
+	 corresponds to this symbol.  This is the index of this symbol
+	 in all the symbols for which we are making plt entries.  The
+	 first entry in the procedure linkage table is reserved.  */
+      plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
+
+      /* Get the offset into the .got table of the entry that
+	 corresponds to this function.  Each .got entry is 4 bytes.
+	 The first three are reserved.  */
+      got_offset = (plt_index + 3) * 4;
+
+#ifdef GOT_BIAS
+      got_offset -= GOT_BIAS;
+#endif
+
+      /* Fill in the entry in the procedure linkage table.  */
+      if (! info->shared)
+	{
+	  if (elf_sh_plt_entry == NULL)
+	    {
+	      elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
+				  elf_sh_plt_entry_be : elf_sh_plt_entry_le);
+	    }
+	  memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
+		  elf_sh_sizeof_plt (info));
+#ifdef INCLUDE_SHMEDIA
+	  movi_shori_putval (output_bfd,
+			     (sgot->output_section->vma
+			      + sgot->output_offset
+			      + got_offset),
+			     (splt->contents + h->plt.offset
+			      + elf_sh_plt_symbol_offset (info)));
+
+	  movi_shori_putval (output_bfd,
+			     (splt->output_section->vma + splt->output_offset),
+			     (splt->contents + h->plt.offset
+			      + elf_sh_plt_plt0_offset (info)));
+#else
+	  bfd_put_32 (output_bfd,
+		      (sgot->output_section->vma
+		       + sgot->output_offset
+		       + got_offset),
+		      (splt->contents + h->plt.offset
+		       + elf_sh_plt_symbol_offset (info)));
+
+	  bfd_put_32 (output_bfd,
+		      (splt->output_section->vma + splt->output_offset),
+		      (splt->contents + h->plt.offset
+		       + elf_sh_plt_plt0_offset (info)));
+#endif
+	}
+      else
+	{
+	  if (elf_sh_pic_plt_entry == NULL)
+	    {
+	      elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
+				      elf_sh_pic_plt_entry_be :
+				      elf_sh_pic_plt_entry_le);
+	    }
+	  memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
+		  elf_sh_sizeof_plt (info));
+#ifdef INCLUDE_SHMEDIA
+	  movi_shori_putval (output_bfd, got_offset,
+			     (splt->contents + h->plt.offset
+			      + elf_sh_plt_symbol_offset (info)));
+#else
+	  bfd_put_32 (output_bfd, got_offset,
+		      (splt->contents + h->plt.offset
+		       + elf_sh_plt_symbol_offset (info)));
+#endif
+	}
+
+#ifdef GOT_BIAS
+      got_offset += GOT_BIAS;
+#endif
+
+#ifdef INCLUDE_SHMEDIA
+      movi_shori_putval (output_bfd,
+			 plt_index * sizeof (Elf32_External_Rela),
+			 (splt->contents + h->plt.offset
+			  + elf_sh_plt_reloc_offset (info)));
+#else
+      bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
+		  (splt->contents + h->plt.offset
+		   + elf_sh_plt_reloc_offset (info)));
+#endif
+
+      /* Fill in the entry in the global offset table.  */
+      bfd_put_32 (output_bfd,
+		  (splt->output_section->vma
+		   + splt->output_offset
+		   + h->plt.offset
+		   + elf_sh_plt_temp_offset (info)),
+		  sgot->contents + got_offset);
+
+      /* Fill in the entry in the .rela.plt section.  */
+      rel.r_offset = (sgot->output_section->vma
+		      + sgot->output_offset
+		      + got_offset);
+      rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
+      rel.r_addend = 0;
+#ifdef GOT_BIAS
+      rel.r_addend = GOT_BIAS;
+#endif
+      bfd_elf32_swap_reloca_out (output_bfd, &rel,
+				((Elf32_External_Rela *) srel->contents
+				 + plt_index));
+
+      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+	{
+	  /* Mark the symbol as undefined, rather than as defined in
+	     the .plt section.  Leave the value alone.  */
+	  sym->st_shndx = SHN_UNDEF;
+	}
+    }
+
+  if (h->got.offset != (bfd_vma) -1)
+    {
+      asection *sgot;
+      asection *srel;
+      Elf_Internal_Rela rel;
+
+      /* This symbol has an entry in the global offset table.  Set it
+	 up.  */
+
+      sgot = htab->sgot;
+      srel = htab->srelgot;
+      BFD_ASSERT (sgot != NULL && srel != NULL);
+
+      rel.r_offset = (sgot->output_section->vma
+		      + sgot->output_offset
+		      + (h->got.offset &~ (bfd_vma) 1));
+
+      /* If this is a static link, or it is a -Bsymbolic link and the
+	 symbol is defined locally or was forced to be local because
+	 of a version file, we just want to emit a RELATIVE reloc.
+	 The entry in the global offset table will already have been
+	 initialized in the relocate_section function.  */
+      if (info->shared
+	  && (info->symbolic
+	      || h->dynindx == -1
+	      || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
+	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
+	{
+	  rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
+	  rel.r_addend = (h->root.u.def.value
+			  + h->root.u.def.section->output_section->vma
+			  + h->root.u.def.section->output_offset);
+	}
+      else
+	{
+	  bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
+	  rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
+	  rel.r_addend = 0;
+	}
+
+      bfd_elf32_swap_reloca_out (output_bfd, &rel,
+				 ((Elf32_External_Rela *) srel->contents
+				  + srel->reloc_count));
+      ++srel->reloc_count;
+    }
+
+  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
+    {
+      asection *s;
+      Elf_Internal_Rela rel;
+
+      /* This symbol needs a copy reloc.  Set it up.  */
+
+      BFD_ASSERT (h->dynindx != -1
+		  && (h->root.type == bfd_link_hash_defined
+		      || h->root.type == bfd_link_hash_defweak));
+
+      s = bfd_get_section_by_name (h->root.u.def.section->owner,
+				   ".rela.bss");
+      BFD_ASSERT (s != NULL);
+
+      rel.r_offset = (h->root.u.def.value
+		      + h->root.u.def.section->output_section->vma
+		      + h->root.u.def.section->output_offset);
+      rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
+      rel.r_addend = 0;
+      bfd_elf32_swap_reloca_out (output_bfd, &rel,
+				 ((Elf32_External_Rela *) s->contents
+				  + s->reloc_count));
+      ++s->reloc_count;
+    }
+
+  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
+  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+      || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
+    sym->st_shndx = SHN_ABS;
+
+  return true;
+}
+
+/* Finish up the dynamic sections.  */
+
+static boolean
+sh_elf_finish_dynamic_sections (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  struct elf_sh_link_hash_table *htab;
+  bfd *dynobj;
+  asection *sgot;
+  asection *sdyn;
+
+  htab = sh_elf_hash_table (info);
+  dynobj = htab->root.dynobj;
+
+  sgot = htab->sgotplt;
+  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+
+  if (htab->root.dynamic_sections_created)
+    {
+      asection *splt;
+      Elf32_External_Dyn *dyncon, *dynconend;
+
+      BFD_ASSERT (sgot != NULL && sdyn != NULL);
+
+      dyncon = (Elf32_External_Dyn *) sdyn->contents;
+      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
+      for (; dyncon < dynconend; dyncon++)
+	{
+	  Elf_Internal_Dyn dyn;
+	  asection *s;
+
+	  bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
+
+	  switch (dyn.d_tag)
+	    {
+	    default:
+	      break;
+
+	    case DT_PLTGOT:
+	      s = htab->sgot->output_section;
+	      goto get_vma;
+
+	    case DT_JMPREL:
+	      s = htab->srelplt->output_section;
+	    get_vma:
+	      BFD_ASSERT (s != NULL);
+	      dyn.d_un.d_ptr = s->vma;
+	      bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+	      break;
+
+	    case DT_PLTRELSZ:
+	      s = htab->srelplt->output_section;
+	      BFD_ASSERT (s != NULL);
+	      if (s->_cooked_size != 0)
+		dyn.d_un.d_val = s->_cooked_size;
+	      else
+		dyn.d_un.d_val = s->_raw_size;
+	      bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+	      break;
+
+	    case DT_RELASZ:
+	      /* My reading of the SVR4 ABI indicates that the
+		 procedure linkage table relocs (DT_JMPREL) should be
+		 included in the overall relocs (DT_RELA).  This is
+		 what Solaris does.  However, UnixWare can not handle
+		 that case.  Therefore, we override the DT_RELASZ entry
+		 here to make it not include the JMPREL relocs.  Since
+		 the linker script arranges for .rela.plt to follow all
+		 other relocation sections, we don't have to worry
+		 about changing the DT_RELA entry.  */
+	      if (htab->srelplt != NULL)
+		{
+		  s = htab->srelplt->output_section;
+		  if (s->_cooked_size != 0)
+		    dyn.d_un.d_val -= s->_cooked_size;
+		  else
+		    dyn.d_un.d_val -= s->_raw_size;
+		}
+	      bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+	      break;
+	    }
+	}
+
+      /* Fill in the first entry in the procedure linkage table.  */
+      splt = htab->splt;
+      if (splt && splt->_raw_size > 0)
+	{
+	  if (info->shared)
+	    {
+	      if (elf_sh_pic_plt_entry == NULL)
+		{
+		  elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
+					  elf_sh_pic_plt_entry_be :
+					  elf_sh_pic_plt_entry_le);
+		}
+	      memcpy (splt->contents, elf_sh_pic_plt_entry,
+		      elf_sh_sizeof_plt (info));
+	    }
+	  else
+	    {
+	      if (elf_sh_plt0_entry == NULL)
+		{
+		  elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
+				       elf_sh_plt0_entry_be :
+				       elf_sh_plt0_entry_le);
+		}
+	      memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
+#ifdef INCLUDE_SHMEDIA
+	      movi_shori_putval (output_bfd,
+				 sgot->output_section->vma
+				 + sgot->output_offset,
+				 splt->contents
+				 + elf_sh_plt0_gotplt_offset (info));
+#else
+	      bfd_put_32 (output_bfd,
+			  sgot->output_section->vma + sgot->output_offset + 4,
+			  splt->contents + elf_sh_plt0_gotid_offset (info));
+	      bfd_put_32 (output_bfd,
+			  sgot->output_section->vma + sgot->output_offset + 8,
+			  splt->contents + elf_sh_plt0_linker_offset (info));
+#endif
+	    }
+
+	  /* UnixWare sets the entsize of .plt to 4, although that doesn't
+	     really seem like the right value.  */
+	  elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
+	}
+    }
+
+  /* Fill in the first three entries in the global offset table.  */
+  if (sgot && sgot->_raw_size > 0)
+    {
+      if (sdyn == NULL)
+	bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
+      else
+	bfd_put_32 (output_bfd,
+		    sdyn->output_section->vma + sdyn->output_offset,
+		    sgot->contents);
+      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
+      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
+
+      elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
+    }
+
+  return true;
+}
+
+static enum elf_reloc_type_class
+sh_elf_reloc_type_class (rela)
+     const Elf_Internal_Rela *rela;
+{
+  switch ((int) ELF32_R_TYPE (rela->r_info))
+    {
+    case R_SH_RELATIVE:
+      return reloc_class_relative;
+    case R_SH_JMP_SLOT:
+      return reloc_class_plt;
+    case R_SH_COPY:
+      return reloc_class_copy;
+    default:
+      return reloc_class_normal;
+    }
+}
+
+#ifndef ELF_ARCH
+#define TARGET_BIG_SYM		bfd_elf32_sh_vec
+#define TARGET_BIG_NAME		"elf32-sh"
+#define TARGET_LITTLE_SYM	bfd_elf32_shl_vec
+#define TARGET_LITTLE_NAME	"elf32-shl"
+#define ELF_ARCH		bfd_arch_sh
+#define ELF_MACHINE_CODE	EM_SH
+#define ELF_MAXPAGESIZE		128
+
+#define elf_symbol_leading_char '_'
+#endif /* ELF_ARCH */
+
+#define bfd_elf32_bfd_reloc_type_lookup	sh_elf_reloc_type_lookup
+#define elf_info_to_howto		sh_elf_info_to_howto
+#define bfd_elf32_bfd_relax_section	sh_elf_relax_section
+#define elf_backend_relocate_section	sh_elf_relocate_section
+#define bfd_elf32_bfd_get_relocated_section_contents \
+					sh_elf_get_relocated_section_contents
+#define elf_backend_object_p		sh_elf_set_mach_from_flags
+#define bfd_elf32_bfd_set_private_bfd_flags \
+					sh_elf_set_private_flags
+#define bfd_elf32_bfd_copy_private_bfd_data \
+					sh_elf_copy_private_data
+#define bfd_elf32_bfd_merge_private_bfd_data \
+					sh_elf_merge_private_data
+
+#define elf_backend_gc_mark_hook	sh_elf_gc_mark_hook
+#define elf_backend_gc_sweep_hook	sh_elf_gc_sweep_hook
+#define elf_backend_check_relocs	sh_elf_check_relocs
+#define elf_backend_copy_indirect_symbol \
+					sh_elf_copy_indirect_symbol
+#define elf_backend_create_dynamic_sections \
+					sh_elf_create_dynamic_sections
+#define bfd_elf32_bfd_link_hash_table_create \
+					sh_elf_link_hash_table_create
+#define elf_backend_adjust_dynamic_symbol \
+					sh_elf_adjust_dynamic_symbol
+#define elf_backend_size_dynamic_sections \
+					sh_elf_size_dynamic_sections
+#define elf_backend_finish_dynamic_symbol \
+					sh_elf_finish_dynamic_symbol
+#define elf_backend_finish_dynamic_sections \
+					sh_elf_finish_dynamic_sections
+#define elf_backend_reloc_type_class	sh_elf_reloc_type_class
+
+#define elf_backend_can_gc_sections	1
+#define elf_backend_can_refcount	1
+#define elf_backend_want_got_plt	1
+#define elf_backend_plt_readonly	1
+#define elf_backend_want_plt_sym	0
+#define elf_backend_got_header_size	12
+#define elf_backend_plt_header_size	PLT_ENTRY_SIZE
+#include "elf32-target.h"
diff --git a/contrib/binutils/bfd/elf32-sparc.c b/contrib/binutils/bfd/elf32-sparc.c
index 38200dc..b6cf7eb 100644
--- a/contrib/binutils/bfd/elf32-sparc.c
+++ b/contrib/binutils/bfd/elf32-sparc.c
@@ -1298,7 +1298,6 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 		off &= ~1;
 	      else
 		{
-		  bfd_put_32 (output_bfd, relocation, sgot->contents + off);
 
 		  if (info->shared)
 		    {
@@ -1314,7 +1313,8 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 					 + sgot->output_offset
 					 + off);
 		      outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
-		      outrel.r_addend = 0;
+		      outrel.r_addend = relocation;
+		      relocation = 0;
 		      bfd_elf32_swap_reloca_out (output_bfd, &outrel,
 						 (((Elf32_External_Rela *)
 						   srelgot->contents)
@@ -1322,6 +1322,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 		      ++srelgot->reloc_count;
 		    }
 
+		  bfd_put_32 (output_bfd, relocation, sgot->contents + off);
 		  local_got_offsets[r_symndx] |= 1;
 		}
 	    }
@@ -1827,14 +1828,21 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
       if (info->shared
 	  && (info->symbolic || h->dynindx == -1)
 	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
-	rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
+	{
+	  asection *sec = h->root.u.def.section;
+	  rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
+	  rela.r_addend = (h->root.u.def.value
+			   + sec->output_section->vma
+			   + sec->output_offset);
+	}
       else
 	{
-	  bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
 	  rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
+	  rela.r_addend = 0;
 	}
 
-      rela.r_addend = 0;
+      bfd_put_32 (output_bfd, (bfd_vma) 0,
+		  sgot->contents + (h->got.offset &~ (bfd_vma) 1));
       bfd_elf32_swap_reloca_out (output_bfd, &rela,
 				 ((Elf32_External_Rela *) srela->contents
 				  + srela->reloc_count));
diff --git a/contrib/binutils/bfd/elf32-v850.c b/contrib/binutils/bfd/elf32-v850.c
index ae0a0c4..6762190 100644
--- a/contrib/binutils/bfd/elf32-v850.c
+++ b/contrib/binutils/bfd/elf32-v850.c
@@ -1,5 +1,5 @@
 /* V850-specific support for 32-bit ELF
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
 This file is part of BFD, the Binary File Descriptor library.
@@ -79,12 +79,12 @@ static boolean v850_elf_link_output_symbol_hook
   PARAMS ((bfd *, struct bfd_link_info *, const char *,
 	   Elf_Internal_Sym *, asection *));
 static boolean v850_elf_section_from_shdr
-  PARAMS ((bfd *, Elf_Internal_Shdr *, char *));
+  PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
 static boolean v850_elf_gc_sweep_hook
   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 	   const Elf_Internal_Rela *));
 static asection * v850_elf_gc_mark_hook
-  PARAMS ((bfd *, struct bfd_link_info *,
+  PARAMS ((asection *, struct bfd_link_info *,
 	   Elf_Internal_Rela *, struct elf_link_hash_entry *,
 	   Elf_Internal_Sym *));
 
@@ -1322,7 +1322,7 @@ v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
 		nop
 	foo:
         	nop      */
-  if (reloc->howto->pc_relative == true)
+  if (reloc->howto->pc_relative)
     {
       /* Here the variable relocation holds the final address of the
 	 symbol we are relocating against, plus any addend.  */
@@ -1740,8 +1740,8 @@ v850_elf_gc_sweep_hook (abfd, info, sec, relocs)
 }
 
 static asection *
-v850_elf_gc_mark_hook (abfd, info, rel, h, sym)
-       bfd *abfd;
+v850_elf_gc_mark_hook (sec, info, rel, h, sym)
+       asection *sec;
        struct bfd_link_info *info ATTRIBUTE_UNUSED;
        Elf_Internal_Rela *rel;
        struct elf_link_hash_entry *h;
@@ -1771,9 +1771,7 @@ v850_elf_gc_mark_hook (abfd, info, rel, h, sym)
        }
      }
    else
-     {
-       return bfd_section_from_elf_index (abfd, sym->st_shndx);
-     }
+     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 
   return NULL;
 }
@@ -2135,7 +2133,7 @@ static boolean
 v850_elf_section_from_shdr (abfd, hdr, name)
      bfd *               abfd;
      Elf_Internal_Shdr * hdr;
-     char *              name;
+     const char *        name;
 {
   /* There ought to be a place to keep ELF backend specific flags, but
      at the moment there isn't one.  We just keep track of the
diff --git a/contrib/binutils/bfd/elf64-alpha.c b/contrib/binutils/bfd/elf64-alpha.c
index e1d095d..7397ed1 100644
--- a/contrib/binutils/bfd/elf64-alpha.c
+++ b/contrib/binutils/bfd/elf64-alpha.c
@@ -2480,6 +2480,7 @@ elf64_alpha_create_dynamic_sections (abfd, info)
 {
   asection *s;
   struct elf_link_hash_entry *h;
+  struct bfd_link_hash_entry *bh;
 
   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
 
@@ -2495,13 +2496,13 @@ elf64_alpha_create_dynamic_sections (abfd, info)
 
   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
      .plt section.  */
-  h = NULL;
+  bh = NULL;
   if (! (_bfd_generic_link_add_one_symbol
 	 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
 	  (bfd_vma) 0, (const char *) NULL, false,
-	  get_elf_backend_data (abfd)->collect,
-	  (struct bfd_link_hash_entry **) &h)))
+	  get_elf_backend_data (abfd)->collect, &bh)))
     return false;
+  h = (struct elf_link_hash_entry *) bh;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
   h->type = STT_OBJECT;
 
@@ -2539,13 +2540,13 @@ elf64_alpha_create_dynamic_sections (abfd, info)
      dynobj's .got section.  We don't do this in the linker script
      because we don't want to define the symbol if we are not creating
      a global offset table.  */
-  h = NULL;
+  bh = NULL;
   if (!(_bfd_generic_link_add_one_symbol
 	(info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
 	 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
-	 false, get_elf_backend_data (abfd)->collect,
-	 (struct bfd_link_hash_entry **) &h)))
+	 false, get_elf_backend_data (abfd)->collect, &bh)))
     return false;
+  h = (struct elf_link_hash_entry *) bh;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
   h->type = STT_OBJECT;
 
@@ -3099,7 +3100,7 @@ elf64_alpha_check_relocs (abfd, info, sec, relocs)
 
 	case R_ALPHA_REFLONG:
 	case R_ALPHA_REFQUAD:
-	  if (info->shared || maybe_dynamic)
+	  if ((info->shared && (sec->flags & SEC_ALLOC)) || maybe_dynamic)
 	    need = NEED_DYNREL;
 	  break;
 
@@ -4576,7 +4577,7 @@ elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
 	      case STO_ALPHA_NOPV:
 	        break;
 	      case STO_ALPHA_STD_GPLOAD:
-		addend += 8;
+		value += 8;
 		break;
 	      default:
 		if (h != NULL)
diff --git a/contrib/binutils/bfd/elf64-ppc.c b/contrib/binutils/bfd/elf64-ppc.c
index e431c14..c512636 100644
--- a/contrib/binutils/bfd/elf64-ppc.c
+++ b/contrib/binutils/bfd/elf64-ppc.c
@@ -1661,6 +1661,7 @@ ppc64_elf_merge_private_bfd_data (ibfd, obfd)
 {
   /* Check if we have the same endianess.  */
   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
+      && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
     {
       const char *msg;
@@ -1788,19 +1789,19 @@ struct ppc_dyn_relocs
    ppc_stub_plt_branch:
    Similar to the above, but a 24 bit branch in the stub section won't
    reach its destination.
-   .	addis	%r12,%r2,xxx@ha
-   .	ld	%r11,xxx@l(%r12)
+   .	addis	%r12,%r2,xxx@toc@ha
+   .	ld	%r11,xxx@toc@l(%r12)
    .	mtctr	%r11
    .	bctr
 
    ppc_stub_plt_call:
    Used to call a function in a shared library.
-   .	addis	%r12,%r2,xxx@ha
+   .	addis	%r12,%r2,xxx@toc@ha
    .	std	%r2,40(%r1)
-   .	ld	%r11,xxx+0@l(%r12)
-   .	ld	%r2,xxx+8@l(%r12)
+   .	ld	%r11,xxx+0@toc@l(%r12)
+   .	ld	%r2,xxx+8@toc@l(%r12)
    .	mtctr	%r11
-   .	ld	%r11,xxx+16@l(%r12)
+   .	ld	%r11,xxx+16@toc@l(%r12)
    .	bctr
 */
 
@@ -3169,6 +3170,7 @@ func_desc_adjust (h, inf)
 	{
 	  bfd *abfd;
 	  asymbol *newsym;
+	  struct bfd_link_hash_entry *bh;
 
 	  abfd = h->root.u.undef.abfd;
 	  newsym = bfd_make_empty_symbol (abfd);
@@ -3179,13 +3181,14 @@ func_desc_adjust (h, inf)
 	  if (h->root.type == bfd_link_hash_undefweak)
 	    newsym->flags |= BSF_WEAK;
 
+	  bh = &fdh->root;
 	  if ( !(_bfd_generic_link_add_one_symbol
 		 (info, abfd, newsym->name, newsym->flags,
-		  newsym->section, newsym->value, NULL, false, false,
-		  (struct bfd_link_hash_entry **) &fdh)))
+		  newsym->section, newsym->value, NULL, false, false, &bh)))
 	    {
 	      return false;
 	    }
+	  fdh = (struct elf_link_hash_entry *) bh;
 	  fdh->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
 	}
 
@@ -3805,8 +3808,7 @@ edit_opd (obfd, info)
 			     for the function descriptor sym which we
 			     don't have at the moment.  So keep an
 			     array of adjustments.  */ 
-			  adjust[(rel->r_offset + wptr - rptr) / 24]
-			    = wptr - rptr;
+			  adjust[rel->r_offset / 24] = wptr - rptr;
 			}
 
 		      if (wptr != rptr)
diff --git a/contrib/binutils/bfd/elf64-s390.c b/contrib/binutils/bfd/elf64-s390.c
index 40f4908..5ad1ca7 100644
--- a/contrib/binutils/bfd/elf64-s390.c
+++ b/contrib/binutils/bfd/elf64-s390.c
@@ -40,12 +40,13 @@ static boolean create_got_section
 static boolean elf_s390_create_dynamic_sections
   PARAMS((bfd *, struct bfd_link_info *));
 static void elf_s390_copy_indirect_symbol
-  PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
+  PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
+	   struct elf_link_hash_entry *));
 static boolean elf_s390_check_relocs
   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 	   const Elf_Internal_Rela *));
 static asection *elf_s390_gc_mark_hook
-  PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
+  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
 	   struct elf_link_hash_entry *, Elf_Internal_Sym *));
 static boolean elf_s390_gc_sweep_hook
   PARAMS ((bfd *, struct bfd_link_info *, asection *,
@@ -424,13 +425,13 @@ elf_s390_link_hash_table_create (abfd)
   struct elf_s390_link_hash_table *ret;
   bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
 
-  ret = (struct elf_s390_link_hash_table *) bfd_alloc (abfd, amt);
+  ret = (struct elf_s390_link_hash_table *) bfd_malloc (amt);
   if (ret == NULL)
     return NULL;
 
   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
     {
-      bfd_release (abfd, ret);
+      free (ret);
       return NULL;
     }
 
@@ -471,7 +472,7 @@ create_got_section (dynobj, info)
 				  (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 				   | SEC_IN_MEMORY | SEC_LINKER_CREATED
 				   | SEC_READONLY))
-      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
+      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
     return false;
   return true;
 }
@@ -510,7 +511,8 @@ elf_s390_create_dynamic_sections (dynobj, info)
 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 
 static void
-elf_s390_copy_indirect_symbol (dir, ind)
+elf_s390_copy_indirect_symbol (bed, dir, ind)
+     struct elf_backend_data *bed;
      struct elf_link_hash_entry *dir, *ind;
 {
   struct elf_s390_link_hash_entry *edir, *eind;
@@ -552,7 +554,7 @@ elf_s390_copy_indirect_symbol (dir, ind)
       eind->dyn_relocs = NULL;
     }
 
-  _bfd_elf_link_hash_copy_indirect (dir, ind);
+  _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 }
 
 /* Look through the relocs for a section during the first phase, and
@@ -776,7 +778,7 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 			flags |= SEC_ALLOC | SEC_LOAD;
 		      if (sreloc == NULL
 			  || ! bfd_set_section_flags (dynobj, sreloc, flags)
-			  || ! bfd_set_section_alignment (dynobj, sreloc, 2))
+			  || ! bfd_set_section_alignment (dynobj, sreloc, 3))
 			return false;
 		    }
 		  elf_section_data (sec)->sreloc = sreloc;
@@ -855,8 +857,8 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
    relocation.  */
 
 static asection *
-elf_s390_gc_mark_hook (abfd, info, rel, h, sym)
-     bfd *abfd;
+elf_s390_gc_mark_hook (sec, info, rel, h, sym)
+     asection *sec;
      struct bfd_link_info *info ATTRIBUTE_UNUSED;
      Elf_Internal_Rela *rel;
      struct elf_link_hash_entry *h;
@@ -886,9 +888,7 @@ elf_s390_gc_mark_hook (abfd, info, rel, h, sym)
 	}
     }
   else
-    {
-      return bfd_section_from_elf_index (abfd, sym->st_shndx);
-    }
+    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 
   return NULL;
 }
@@ -1019,7 +1019,7 @@ elf_s390_adjust_dynamic_symbol (info, h)
 
   /* If this is a function, put it in the procedure linkage table.  We
      will fill in the contents of the procedure linkage table later
-     (although we could actually do it here). */
+     (although we could actually do it here).  */
   if (h->type == STT_FUNC
       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
     {
@@ -1937,9 +1937,11 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
           break;
         }
 
+      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
+	 because such sections are not SEC_ALLOC and thus ld.so will
+	 not process them.  */
       if (unresolved_reloc
-	  && !(info->shared
-	       && (input_section->flags & SEC_DEBUGGING) != 0
+	  && !((input_section->flags & SEC_DEBUGGING) != 0
 	       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
 	(*_bfd_error_handler)
 	  (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
@@ -2339,6 +2341,7 @@ const struct elf_size_info s390_elf64_size_info =
   bfd_elf64_write_out_phdrs,
   bfd_elf64_write_shdrs_and_ehdr,
   bfd_elf64_write_relocs,
+  bfd_elf64_swap_symbol_in,
   bfd_elf64_swap_symbol_out,
   bfd_elf64_slurp_reloc_table,
   bfd_elf64_slurp_symbol_table,
diff --git a/contrib/binutils/bfd/elf64-sparc.c b/contrib/binutils/bfd/elf64-sparc.c
index def93c4..a3c100d 100644
--- a/contrib/binutils/bfd/elf64-sparc.c
+++ b/contrib/binutils/bfd/elf64-sparc.c
@@ -1563,6 +1563,9 @@ sparc64_elf_adjust_dynamic_symbol (info, h)
       if (s->_raw_size == 0)
 	s->_raw_size = PLT_HEADER_SIZE;
 
+      /* To simplify matters later, just store the plt index here.  */
+      h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE;
+
       /* If this symbol is not defined in a regular file, and we are
 	 not generating a shared library, then set the symbol to this
 	 location in the .plt.  This is required to make function
@@ -1572,12 +1575,9 @@ sparc64_elf_adjust_dynamic_symbol (info, h)
 	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
 	{
 	  h->root.u.def.section = s;
-	  h->root.u.def.value = s->_raw_size;
+	  h->root.u.def.value = sparc64_elf_plt_entry_offset (h->plt.offset);
 	}
 
-      /* To simplify matters later, just store the plt index here.  */
-      h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE;
-
       /* Make room for this entry.  */
       s->_raw_size += PLT_ENTRY_SIZE;
 
@@ -2181,11 +2181,9 @@ sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 		  }
 		else
 		  {
+		    outrel.r_addend = relocation + rel->r_addend;
 		    if (r_type == R_SPARC_64)
-		      {
-			outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
-			outrel.r_addend = relocation + rel->r_addend;
-		      }
+		      outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
 		    else
 		      {
 			long indx;
@@ -2215,6 +2213,13 @@ sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 			    osec = sec->output_section;
 			    indx = elf_section_data (osec)->dynindx;
 
+			    /* We are turning this relocation into one
+			       against a section symbol, so subtract out
+			       the output section's address but not the
+			       offset of the input section in the output
+			       section.  */
+			    outrel.r_addend -= osec->vma;
+
 			    /* FIXME: we really should be able to link non-pic
 			       shared libraries.  */
 			    if (indx == 0)
@@ -2233,7 +2238,6 @@ sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 					  ELF64_R_TYPE_INFO (
 					    ELF64_R_TYPE_DATA (rel->r_info),
 							       r_type));
-			outrel.r_addend = relocation + rel->r_addend;
 		      }
 		  }
 
diff --git a/contrib/binutils/bfd/elflink.c b/contrib/binutils/bfd/elflink.c
index f8cc645..d6da588 100644
--- a/contrib/binutils/bfd/elflink.c
+++ b/contrib/binutils/bfd/elflink.c
@@ -33,6 +33,7 @@ _bfd_elf_create_got_section (abfd, info)
   flagword flags;
   register asection *s;
   struct elf_link_hash_entry *h;
+  struct bfd_link_hash_entry *bh;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
   int ptralign;
 
@@ -79,12 +80,13 @@ _bfd_elf_create_got_section (abfd, info)
 	 (or .got.plt) section.  We don't do this in the linker script
 	 because we don't want to define the symbol if we are not creating
 	 a global offset table.  */
-      h = NULL;
+      bh = NULL;
       if (!(_bfd_generic_link_add_one_symbol
 	    (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
 	     bed->got_symbol_offset, (const char *) NULL, false,
-	     bed->collect, (struct bfd_link_hash_entry **) &h)))
+	     bed->collect, &bh)))
 	return false;
+      h = (struct elf_link_hash_entry *) bh;
       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
       h->type = STT_OBJECT;
 
@@ -151,13 +153,15 @@ _bfd_elf_create_dynamic_sections (abfd, info)
     {
       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
 	 .plt section.  */
-      struct elf_link_hash_entry *h = NULL;
+      struct elf_link_hash_entry *h;
+      struct bfd_link_hash_entry *bh = NULL;
+
       if (! (_bfd_generic_link_add_one_symbol
 	     (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
 	      (bfd_vma) 0, (const char *) NULL, false,
-	      get_elf_backend_data (abfd)->collect,
-	      (struct bfd_link_hash_entry **) &h)))
+	      get_elf_backend_data (abfd)->collect, &bh)))
 	return false;
+      h = (struct elf_link_hash_entry *) bh;
       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
       h->type = STT_OBJECT;
 
@@ -546,29 +550,27 @@ _bfd_elf_create_linker_section (abfd, info, which, defaults)
 
       if (lsect->sym_name)
 	{
-	  struct elf_link_hash_entry *h = NULL;
+	  struct elf_link_hash_entry *h;
+	  struct bfd_link_hash_entry *bh;
+
 #ifdef DEBUG
 	  fprintf (stderr, "Adding %s to section %s\n",
 		   lsect->sym_name,
 		   lsect->name);
 #endif
-	  h = (struct elf_link_hash_entry *)
-	    bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
-
-	  if ((h == NULL || h->root.type == bfd_link_hash_undefined)
-	      && !(_bfd_generic_link_add_one_symbol (info,
-						     abfd,
-						     lsect->sym_name,
-						     BSF_GLOBAL,
-						     s,
-						     ((lsect->hole_size)
-						      ? s->_raw_size - lsect->hole_size + lsect->sym_offset
-						      : lsect->sym_offset),
-						     (const char *) NULL,
-						     false,
-						     get_elf_backend_data (abfd)->collect,
-						     (struct bfd_link_hash_entry **) &h)))
-	    return (elf_linker_section_t *)0;
+	  bh = bfd_link_hash_lookup (info->hash, lsect->sym_name,
+				     false, false, false);
+
+	  if ((bh == NULL || bh->type == bfd_link_hash_undefined)
+	      && !(_bfd_generic_link_add_one_symbol
+		   (info, abfd, lsect->sym_name, BSF_GLOBAL, s,
+		    (lsect->hole_size
+		     ? s->_raw_size - lsect->hole_size + lsect->sym_offset
+		     : lsect->sym_offset),
+		    (const char *) NULL, false,
+		    get_elf_backend_data (abfd)->collect, &bh)))
+	    return (elf_linker_section_t *) 0;
+	  h = (struct elf_link_hash_entry *) bh;
 
 	  if ((defaults->which != LINKER_SECTION_SDATA)
 	      && (defaults->which != LINKER_SECTION_SDATA2))
@@ -579,7 +581,7 @@ _bfd_elf_create_linker_section (abfd, info, which, defaults)
 
 	  if (info->shared
 	      && ! _bfd_elf_link_record_dynamic_symbol (info, h))
-	    return (elf_linker_section_t *)0;
+	    return (elf_linker_section_t *) 0;
 	}
     }
 
diff --git a/contrib/binutils/bfd/elflink.h b/contrib/binutils/bfd/elflink.h
index 25519b1..6887e50 100644
--- a/contrib/binutils/bfd/elflink.h
+++ b/contrib/binutils/bfd/elflink.h
@@ -921,6 +921,7 @@ elf_add_default_symbol (abfd, info, h, name, sym, psec, value,
   boolean size_change_ok;
   char *shortname;
   struct elf_link_hash_entry *hi;
+  struct bfd_link_hash_entry *bh;
   struct elf_backend_data *bed;
   boolean collect;
   boolean dynamic;
@@ -979,11 +980,12 @@ elf_add_default_symbol (abfd, info, h, name, sym, psec, value,
 
   if (! override)
     {
+      bh = &hi->root;
       if (! (_bfd_generic_link_add_one_symbol
 	     (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
-	      (bfd_vma) 0, name, false, collect,
-	      (struct bfd_link_hash_entry **) &hi)))
+	      (bfd_vma) 0, name, false, collect, &bh)))
 	return false;
+      hi = (struct elf_link_hash_entry *) bh;
     }
   else
     {
@@ -1098,11 +1100,12 @@ elf_add_default_symbol (abfd, info, h, name, sym, psec, value,
     }
   else
     {
+      bh = &hi->root;
       if (! (_bfd_generic_link_add_one_symbol
 	     (info, abfd, shortname, BSF_INDIRECT,
-	      bfd_ind_section_ptr, (bfd_vma) 0, name, false,
-	      collect, (struct bfd_link_hash_entry **) &hi)))
+	      bfd_ind_section_ptr, (bfd_vma) 0, name, false, collect, &bh)))
 	return false;
+      hi = (struct elf_link_hash_entry *) bh;
 
       /* If there is a duplicate definition somewhere, then HI may not
 	 point to an indirect symbol.  We will have reported an error
@@ -1295,6 +1298,14 @@ elf_link_add_object_symbols (abfd, info)
       const char *name;
       bfd_size_type oldsize;
       bfd_size_type strindex;
+      struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
+
+      /* ld --just-symbols and dynamic objects don't mix very well.
+	 Test for --just-symbols by looking at info set up by
+	 _bfd_elf_link_just_syms.  */
+      if ((s = abfd->sections) != NULL
+	  && elf_section_data (s)->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
+	goto error_return;
 
       /* Find the name to use in a DT_NEEDED entry that refers to this
 	 object.  If the object has a DT_SONAME entry, we use it.
@@ -1324,8 +1335,6 @@ elf_link_add_object_symbols (abfd, info)
 	  Elf_External_Dyn *extdynend;
 	  int elfsec;
 	  unsigned long shlink;
-	  int rpath;
-	  int runpath;
 
 	  dynbuf = (Elf_External_Dyn *) bfd_malloc (s->_raw_size);
 	  if (dynbuf == NULL)
@@ -1342,8 +1351,6 @@ elf_link_add_object_symbols (abfd, info)
 
 	  extdyn = dynbuf;
 	  extdynend = extdyn + s->_raw_size / sizeof (Elf_External_Dyn);
-	  rpath = 0;
-	  runpath = 0;
 	  for (; extdyn < extdynend; extdyn++)
 	    {
 	      Elf_Internal_Dyn dyn;
@@ -1387,13 +1394,6 @@ elf_link_add_object_symbols (abfd, info)
 		  char *fnm, *anm;
 		  unsigned int tagv = dyn.d_un.d_val;
 
-		  /* When we see DT_RPATH before DT_RUNPATH, we have
-		     to clear runpath.  Do _NOT_ bfd_release, as that
-		     frees all more recently bfd_alloc'd blocks as
-		     well.  */
-		  if (rpath && hash_table->runpath)
-		    hash_table->runpath = NULL;
-
 		  amt = sizeof (struct bfd_link_needed_list);
 		  n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
 		  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
@@ -1407,13 +1407,11 @@ elf_link_add_object_symbols (abfd, info)
 		  n->name = anm;
 		  n->by = abfd;
 		  n->next = NULL;
-		  for (pn = & hash_table->runpath;
+		  for (pn = & runpath;
 		       *pn != NULL;
 		       pn = &(*pn)->next)
 		    ;
 		  *pn = n;
-		  runpath = 1;
-		  rpath = 0;
 		}
 	      /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
 	      if (!runpath && dyn.d_tag == DT_RPATH)
@@ -1439,18 +1437,32 @@ elf_link_add_object_symbols (abfd, info)
 		  n->name = anm;
 		  n->by = abfd;
 		  n->next = NULL;
-		  for (pn = & hash_table->runpath;
+		  for (pn = & rpath;
 		       *pn != NULL;
 		       pn = &(*pn)->next)
 		    ;
 		  *pn = n;
-		  rpath = 1;
 		}
 	    }
 
 	  free (dynbuf);
 	}
 
+      /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
+	 frees all more recently bfd_alloc'd blocks as well.  */
+      if (runpath)
+	rpath = runpath;
+
+      if (rpath)
+	{
+	  struct bfd_link_needed_list **pn;
+	  for (pn = & hash_table->runpath;
+	       *pn != NULL;
+	       pn = &(*pn)->next)
+	    ;
+	  *pn = rpath;
+	}
+
       /* We do not want to include any of the sections in a dynamic
 	 object in the output file.  We hack by simply clobbering the
 	 list of sections in the BFD.  This could be handled more
@@ -1926,19 +1938,17 @@ elf_link_add_object_symbols (abfd, info)
 	     might be needed here.  */
 	  if (isym->st_other != 0)
 	    {
+	      unsigned char hvis, symvis, other;
+
+	      /* Take the balance of OTHER from the definition.  */
+	      other = (definition ? isym->st_other : h->other);
+	      other &= ~ ELF_ST_VISIBILITY (-1);
+
 	      /* Combine visibilities, using the most constraining one.  */
-	      unsigned char hvis   = ELF_ST_VISIBILITY (h->other);
-	      unsigned char symvis = ELF_ST_VISIBILITY (isym->st_other);
-
-	      if (symvis && (hvis > symvis || hvis == 0))
-		h->other = isym->st_other;
-
-	      /* If neither has visibility, use the st_other of the
-		 definition.  This is an arbitrary choice, since the
-		 other bits have no general meaning.  */
-	      if (!symvis && !hvis
-		  && (definition || h->other == 0))
-		h->other = isym->st_other;
+	      hvis   = ELF_ST_VISIBILITY (h->other);
+	      symvis = ELF_ST_VISIBILITY (isym->st_other);
+
+	      h->other = other | (hvis > symvis ? hvis : symvis);
 	    }
 
 	  /* Set a flag in the hash table entry indicating the type of
@@ -2292,6 +2302,7 @@ elf_link_create_dynamic_sections (abfd, info)
   flagword flags;
   register asection *s;
   struct elf_link_hash_entry *h;
+  struct bfd_link_hash_entry *bh;
   struct elf_backend_data *bed;
 
   if (! is_elf_hash_table (info))
@@ -2384,12 +2395,12 @@ elf_link_create_dynamic_sections (abfd, info)
      creating a .dynamic section.  We don't want to define it if there
      is no .dynamic section, since on some ELF platforms the start up
      code examines it to decide how to initialize the process.  */
-  h = NULL;
+  bh = NULL;
   if (! (_bfd_generic_link_add_one_symbol
 	 (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
-	  (const char *) NULL, false, get_elf_backend_data (abfd)->collect,
-	  (struct bfd_link_hash_entry **) &h)))
+	  (const char *) 0, false, get_elf_backend_data (abfd)->collect, &bh)))
     return false;
+  h = (struct elf_link_hash_entry *) bh;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
   h->type = STT_OBJECT;
 
@@ -3326,19 +3337,20 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
 	      unsigned int cdeps;
 	      struct bfd_elf_version_deps *n;
 	      struct elf_link_hash_entry *h;
+	      struct bfd_link_hash_entry *bh;
 
 	      cdeps = 0;
 	      for (n = t->deps; n != NULL; n = n->next)
 		++cdeps;
 
 	      /* Add a symbol representing this version.  */
-	      h = NULL;
+	      bh = NULL;
 	      if (! (_bfd_generic_link_add_one_symbol
 		     (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
 		      (bfd_vma) 0, (const char *) NULL, false,
-		      get_elf_backend_data (dynobj)->collect,
-		      (struct bfd_link_hash_entry **) &h)))
+		      get_elf_backend_data (dynobj)->collect, &bh)))
 		return false;
+	      h = (struct elf_link_hash_entry *) bh;
 	      h->elf_link_hash_flags &= ~ ELF_LINK_NON_ELF;
 	      h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 	      h->type = STT_OBJECT;
@@ -3886,9 +3898,12 @@ elf_fix_symbol_flags (h, eif)
     {
       struct elf_link_hash_entry *weakdef;
 
+      weakdef = h->weakdef;
+      if (h->root.type == bfd_link_hash_indirect)
+	h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
       BFD_ASSERT (h->root.type == bfd_link_hash_defined
 		  || h->root.type == bfd_link_hash_defweak);
-      weakdef = h->weakdef;
       BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
 		  || weakdef->root.type == bfd_link_hash_defweak);
       BFD_ASSERT (weakdef->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC);
@@ -6335,11 +6350,10 @@ elf_link_output_extsym (h, data)
       sym.st_info = ELF_ST_INFO (bindtype, ELF_ST_TYPE (sym.st_info));
     }
 
-  /* If a symbol is not defined locally, we clear the visibility
-     field.  */
+  /* If a symbol is not defined locally, we clear the visibility field.  */
   if (! finfo->info->relocateable
       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
-    sym.st_other ^= ELF_ST_VISIBILITY (sym.st_other);
+    sym.st_other &= ~ ELF_ST_VISIBILITY (-1);
 
   /* If this symbol should be put in the .dynsym section, then put it
      there now.  We already know the symbol index.  We also fill in
diff --git a/contrib/binutils/bfd/elfxx-ia64.c b/contrib/binutils/bfd/elfxx-ia64.c
index 5302bf6..06a279e 100644
--- a/contrib/binutils/bfd/elfxx-ia64.c
+++ b/contrib/binutils/bfd/elfxx-ia64.c
@@ -651,13 +651,14 @@ static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
    not support brl, and so it gets emulated by the kernel.  */
 #undef USE_BRL
 
+#ifdef USE_BRL
 static const bfd_byte oor_brl[16] =
 {
   0x05, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MLX]        nop.m 0            */
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /*               brl.sptk.few tgt;; */
   0x00, 0x00, 0x00, 0xc0
 };
-
+#else
 static const bfd_byte oor_ip[48] =
 {
   0x04, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MLX]        nop.m 0            */
@@ -670,6 +671,7 @@ static const bfd_byte oor_ip[48] =
   0x60, 0x80, 0x04, 0x80, 0x03, 0x00,  /*               mov b6=r16         */
   0x60, 0x00, 0x80, 0x00               /*               br b6;;            */
 };
+#endif
 
 /* These functions do relaxation for IA-64 ELF.
 
@@ -1271,6 +1273,7 @@ elfNN_ia64_aix_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
 	{
 	  struct elf_backend_data *bed;
 	  struct elfNN_ia64_link_hash_table *ia64_info;
+	  struct bfd_link_hash_entry *bh = NULL;
 
 	  bed = get_elf_backend_data (abfd);
 	  ia64_info = elfNN_ia64_hash_table (info);
@@ -1279,9 +1282,10 @@ elfNN_ia64_aix_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
 		(info, abfd, *namep, BSF_GLOBAL,
 		 bfd_get_section_by_name (abfd, ".bss"),
 		 bed->got_symbol_offset, (const char *) NULL, false,
-		 bed->collect, (struct bfd_link_hash_entry **) &h)))
+		 bed->collect, &bh)))
 	    return false;
 
+	  h = (struct elf_link_hash_entry *) bh;
 	  h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 	  h->type = STT_OBJECT;
 
diff --git a/contrib/binutils/bfd/elfxx-target.h b/contrib/binutils/bfd/elfxx-target.h
index 481ba71..5d7efb0 100644
--- a/contrib/binutils/bfd/elfxx-target.h
+++ b/contrib/binutils/bfd/elfxx-target.h
@@ -385,15 +385,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #ifndef elf_backend_write_section
 #define elf_backend_write_section		NULL
 #endif
-#ifndef elf_backend_set_nonloadable_filepos
-#define elf_backend_set_nonloadable_filepos	NULL
-#endif
-#ifndef elf_backend_is_contained_by_filepos
-#define elf_backend_is_contained_by_filepos	NULL
-#endif
-#ifndef elf_backend_copy_private_bfd_data_p
-#define elf_backend_copy_private_bfd_data_p	NULL
-#endif
 #ifndef elf_backend_mips_irix_compat
 #define elf_backend_mips_irix_compat		NULL
 #endif
@@ -495,9 +486,6 @@ static const struct elf_backend_data elfNN_bed =
   elf_backend_discard_info,
   elf_backend_ignore_discarded_relocs,
   elf_backend_write_section,
-  elf_backend_set_nonloadable_filepos,
-  elf_backend_is_contained_by_filepos,
-  elf_backend_copy_private_bfd_data_p,
   elf_backend_mips_irix_compat,
   elf_backend_mips_rtype_to_howto,
   elf_backend_ecoff_debug_swap,
diff --git a/contrib/binutils/bfd/format.c b/contrib/binutils/bfd/format.c
index 1efa9e2..ef6b46e 100644
--- a/contrib/binutils/bfd/format.c
+++ b/contrib/binutils/bfd/format.c
@@ -132,7 +132,7 @@ bfd_check_format_matches (abfd, format, matching)
     }
 
   if (abfd->format != bfd_unknown)
-    return abfd->format == format;
+    return (boolean) (abfd->format == format);
 
   /* Since the target type was defaulted, check them
      all in the hope that one will be uniquely recognized.  */
@@ -355,7 +355,7 @@ bfd_set_format (abfd, format)
     }
 
   if (abfd->format != bfd_unknown)
-    return abfd->format == format;
+    return (boolean) (abfd->format == format);
 
   /* Presume the answer is yes.  */
   abfd->format = format;
diff --git a/contrib/binutils/bfd/gen-aout.c b/contrib/binutils/bfd/gen-aout.c
index 1bba14a..b6720e8 100644
--- a/contrib/binutils/bfd/gen-aout.c
+++ b/contrib/binutils/bfd/gen-aout.c
@@ -21,6 +21,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "/usr/include/a.out.h"
 #include <stdio.h>
 
+#ifndef _
+#define _(X) X
+#endif
+
 int
 main (argc, argv)
      int argc; char** argv;
diff --git a/contrib/binutils/bfd/libbfd.c b/contrib/binutils/bfd/libbfd.c
index 29170a0..f21abbc 100644
--- a/contrib/binutils/bfd/libbfd.c
+++ b/contrib/binutils/bfd/libbfd.c
@@ -186,9 +186,9 @@ bfd_realloc (ptr, size)
     }
 
   if (ptr == NULL)
-    ret = malloc ((size_t) size);
+    ret = (PTR) malloc ((size_t) size);
   else
-    ret = realloc (ptr, (size_t) size);
+    ret = (PTR) realloc (ptr, (size_t) size);
 
   if (ret == NULL && (size_t) size != 0)
     bfd_set_error (bfd_error_no_memory);
@@ -562,7 +562,7 @@ bfd_bwrite (ptr, size, abfd)
 	  newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 	  if (newsize > oldsize)
 	    {
-	      bim->buffer = bfd_realloc (bim->buffer, newsize);
+	      bim->buffer = (bfd_byte *) bfd_realloc (bim->buffer, newsize);
 	      if (bim->buffer == 0)
 		{
 		  bim->size = 0;
@@ -608,7 +608,7 @@ bfd_write_bigendian_4byte_int (abfd, i)
 {
   bfd_byte buffer[4];
   bfd_putb32 ((bfd_vma) i, buffer);
-  return bfd_bwrite ((PTR) buffer, (bfd_size_type) 4, abfd) == 4;
+  return (boolean) (bfd_bwrite ((PTR) buffer, (bfd_size_type) 4, abfd) == 4);
 }
 
 bfd_vma
@@ -706,7 +706,7 @@ bfd_seek (abfd, position, direction)
 	      newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 	      if (newsize > oldsize)
 	        {
-		  bim->buffer = bfd_realloc (bim->buffer, newsize);
+		  bim->buffer = (bfd_byte *) bfd_realloc (bim->buffer, newsize);
 		  if (bim->buffer == 0)
 		    {
 		      bim->size = 0;
@@ -1414,7 +1414,7 @@ bfd_generic_is_local_label_name (abfd, name)
 {
   char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
 
-  return (name[0] == locals_prefix);
+  return (boolean) (name[0] == locals_prefix);
 }
 
 /*  Can be used from / for bfd_merge_private_bfd_data to check that
diff --git a/contrib/binutils/bfd/libcoff.h b/contrib/binutils/bfd/libcoff.h
index 88b0909..ea9c570 100644
--- a/contrib/binutils/bfd/libcoff.h
+++ b/contrib/binutils/bfd/libcoff.h
@@ -784,7 +784,7 @@ typedef struct
             struct coff_link_hash_entry *, struct internal_syment *,
             bfd_vma *));
 
-  boolean (*_bfd_coff_adjust_symndx)\
+  boolean (*_bfd_coff_adjust_symndx)
     PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
             struct internal_reloc *, boolean *));
 
diff --git a/contrib/binutils/bfd/linker.c b/contrib/binutils/bfd/linker.c
index 242f8bd..a5ded1f 100644
--- a/contrib/binutils/bfd/linker.c
+++ b/contrib/binutils/bfd/linker.c
@@ -449,7 +449,8 @@ _bfd_link_hash_newfunc (entry, table, string)
      subclass.  */
   if (entry == NULL)
     {
-      entry = bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry));
+      entry = (struct bfd_hash_entry *)
+	bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry));
       if (entry == NULL)
 	return entry;
     }
@@ -645,8 +646,8 @@ _bfd_generic_link_hash_newfunc (entry, table, string)
      subclass.  */
   if (entry == NULL)
     {
-      entry = bfd_hash_allocate (table,
-				 sizeof (struct generic_link_hash_entry));
+      entry = (struct bfd_hash_entry *)
+	bfd_hash_allocate (table, sizeof (struct generic_link_hash_entry));
       if (entry == NULL)
 	return entry;
     }
@@ -1305,6 +1306,7 @@ generic_link_add_symbol_list (abfd, info, symbol_count, symbols, collect)
 	  const char *name;
 	  const char *string;
 	  struct generic_link_hash_entry *h;
+	  struct bfd_link_hash_entry *bh;
 
 	  name = bfd_asymbol_name (p);
 	  if (((p->flags & BSF_INDIRECT) != 0
@@ -1326,12 +1328,12 @@ generic_link_add_symbol_list (abfd, info, symbol_count, symbols, collect)
 	  else
 	    string = NULL;
 
-	  h = NULL;
+	  bh = NULL;
 	  if (! (_bfd_generic_link_add_one_symbol
 		 (info, abfd, name, p->flags, bfd_get_section (p),
-		  p->value, string, false, collect,
-		  (struct bfd_link_hash_entry **) &h)))
+		  p->value, string, false, collect, &bh)))
 	    return false;
+	  h = (struct generic_link_hash_entry *) bh;
 
 	  /* If this is a constructor symbol, and the linker didn't do
              anything with it, then we want to just pass the symbol
@@ -2018,7 +2020,7 @@ _bfd_generic_final_link (abfd, info)
   for (o = abfd->sections; o != NULL; o = o->next)
     for (p = o->link_order_head; p != NULL; p = p->next)
       if (p->type == bfd_indirect_link_order)
-	p->u.indirect.section->linker_mark = true;
+	p->u.indirect.section->linker_mark = (unsigned int) true;
 
   /* Build the output symbol table.  */
   for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
diff --git a/contrib/binutils/bfd/merge.c b/contrib/binutils/bfd/merge.c
index ce61207..9dc2e70 100644
--- a/contrib/binutils/bfd/merge.c
+++ b/contrib/binutils/bfd/merge.c
@@ -353,7 +353,7 @@ sec_merge_emit (abfd, entry)
   if (alignment_power)
     free (pad);
 
-  return entry == NULL || entry->secinfo != secinfo;
+  return (boolean) (entry == NULL || entry->secinfo != secinfo);
 }
 
 /* This function is called for each input file from the add_symbols
@@ -667,7 +667,7 @@ merge_strings (sinfo)
 	break;
       if (e->len > 4 * e->u.entsize)
 	{
-	  s = e->root.string + e->len - e->u.entsize;
+	  s = (const unsigned char *) (e->root.string + e->len - e->u.entsize);
 	  hash = 0;
 	  for (i = 0; i < 4 * e->u.entsize; i++)
 	    {
@@ -690,7 +690,7 @@ merge_strings (sinfo)
 	  else
 	    *p = (PTR) e;
 	}
-      s = e->root.string + e->len - e->u.entsize;
+      s = (const unsigned char *) (e->root.string + e->len - e->u.entsize);
       hash = 0;
       for (i = 0; i < e->u.entsize; i++)
 	{
diff --git a/contrib/binutils/bfd/peicode.h b/contrib/binutils/bfd/peicode.h
index 323b30d..a621acc 100644
--- a/contrib/binutils/bfd/peicode.h
+++ b/contrib/binutils/bfd/peicode.h
@@ -1,5 +1,5 @@
 /* Support for the generic parts of PE/PEI, for BFD.
-   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001
+   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
    Free Software Foundation, Inc.
    Written by Cygnus Solutions.
 
@@ -312,7 +312,7 @@ pe_mkobject_hook (abfd, filehdr, aouthdr)
   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
   pe_data_type *pe;
 
-  if (pe_mkobject (abfd) == false)
+  if (! pe_mkobject (abfd))
     return NULL;
 
   pe = pe_data (abfd);
@@ -1207,7 +1207,10 @@ _("%s: Recognised but unhandled machine type (0x%x) in Import Library Format arc
     return NULL;
 
   if (bfd_bread (ptr, size, abfd) != size)
-    return NULL;
+    {
+      bfd_release (abfd, ptr);
+      return NULL;
+    }
 
   symbol_name = ptr;
   source_dll  = ptr + strlen (ptr) + 1;
@@ -1219,14 +1222,17 @@ _("%s: Recognised but unhandled machine type (0x%x) in Import Library Format arc
 	(_("%s: string not null terminated in ILF object file."),
 	 bfd_archive_filename (abfd));
       bfd_set_error (bfd_error_malformed_archive);
-
+      bfd_release (abfd, ptr);
       return NULL;
     }
 
   /* Now construct the bfd.  */
   if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name,
 			    source_dll, ordinal, types))
-    return NULL;
+    {
+      bfd_release (abfd, ptr);
+      return NULL;
+    }
 
   return abfd->xvec;
 }
diff --git a/contrib/binutils/bfd/po/SRC-POTFILES.in b/contrib/binutils/bfd/po/SRC-POTFILES.in
index e448599..9a977f5 100644
--- a/contrib/binutils/bfd/po/SRC-POTFILES.in
+++ b/contrib/binutils/bfd/po/SRC-POTFILES.in
@@ -134,6 +134,7 @@ elf32-h8300.c
 elf32-hppa.c
 elf32-hppa.h
 elf32-i370.c
+elf32-i386-fbsd.c
 elf32-i386.c
 elf32-i386qnx.c
 elf32-i860.c
@@ -161,6 +162,7 @@ elf32-v850.c
 elf32-vax.c
 elf32-xstormy16.c
 elf32.c
+elf64-alpha-fbsd.c
 elf64-alpha.c
 elf64-gen.c
 elf64-hppa.c
diff --git a/contrib/binutils/bfd/po/bfd.pot b/contrib/binutils/bfd/po/bfd.pot
index 2b9a34a..8823e66 100644
--- a/contrib/binutils/bfd/po/bfd.pot
+++ b/contrib/binutils/bfd/po/bfd.pot
@@ -1,12 +1,13 @@
 # SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR Free Software Foundation, Inc.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
-"POT-Creation-Date: 2002-07-23 15:55-0400\n"
+"POT-Creation-Date: 2002-10-30 10:06-0500\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -54,115 +55,115 @@ msgstr ""
 msgid "%s: relocateable link from %s to %s not supported"
 msgstr ""
 
-#: archive.c:1826
+#: archive.c:1818
 msgid "Warning: writing archive was slow: rewriting timestamp\n"
 msgstr ""
 
-#: archive.c:2093
+#: archive.c:2085
 msgid "Reading archive file mod timestamp"
 msgstr ""
 
 #. FIXME: bfd can't call perror.
-#: archive.c:2120
+#: archive.c:2112
 msgid "Writing updated armap timestamp"
 msgstr ""
 
-#: bfd.c:274
+#: bfd.c:277
 msgid "No error"
 msgstr ""
 
-#: bfd.c:275
+#: bfd.c:278
 msgid "System call error"
 msgstr ""
 
-#: bfd.c:276
+#: bfd.c:279
 msgid "Invalid bfd target"
 msgstr ""
 
-#: bfd.c:277
+#: bfd.c:280
 msgid "File in wrong format"
 msgstr ""
 
-#: bfd.c:278
+#: bfd.c:281
 msgid "Archive object file in wrong format"
 msgstr ""
 
-#: bfd.c:279
+#: bfd.c:282
 msgid "Invalid operation"
 msgstr ""
 
-#: bfd.c:280
+#: bfd.c:283
 msgid "Memory exhausted"
 msgstr ""
 
-#: bfd.c:281
+#: bfd.c:284
 msgid "No symbols"
 msgstr ""
 
-#: bfd.c:282
+#: bfd.c:285
 msgid "Archive has no index; run ranlib to add one"
 msgstr ""
 
-#: bfd.c:283
+#: bfd.c:286
 msgid "No more archived files"
 msgstr ""
 
-#: bfd.c:284
+#: bfd.c:287
 msgid "Malformed archive"
 msgstr ""
 
-#: bfd.c:285
+#: bfd.c:288
 msgid "File format not recognized"
 msgstr ""
 
-#: bfd.c:286
+#: bfd.c:289
 msgid "File format is ambiguous"
 msgstr ""
 
-#: bfd.c:287
+#: bfd.c:290
 msgid "Section has no contents"
 msgstr ""
 
-#: bfd.c:288
+#: bfd.c:291
 msgid "Nonrepresentable section on output"
 msgstr ""
 
-#: bfd.c:289
+#: bfd.c:292
 msgid "Symbol needs debug section which does not exist"
 msgstr ""
 
-#: bfd.c:290
+#: bfd.c:293
 msgid "Bad value"
 msgstr ""
 
-#: bfd.c:291
+#: bfd.c:294
 msgid "File truncated"
 msgstr ""
 
-#: bfd.c:292
+#: bfd.c:295
 msgid "File too big"
 msgstr ""
 
-#: bfd.c:293
+#: bfd.c:296
 msgid "#<Invalid error code>"
 msgstr ""
 
-#: bfd.c:700
+#: bfd.c:703
 #, c-format
 msgid "BFD %s assertion fail %s:%d"
 msgstr ""
 
-#: bfd.c:719
+#: bfd.c:722
 #, c-format
 msgid "BFD %s internal error, aborting at %s line %d in %s\n"
 msgstr ""
 
-#: bfd.c:723
+#: bfd.c:726
 #, c-format
 msgid "BFD %s internal error, aborting at %s line %d\n"
 msgstr ""
 
-#: bfd.c:725
+#: bfd.c:728
 msgid "Please report this bug.\n"
 msgstr ""
 
@@ -209,17 +210,17 @@ msgstr ""
 msgid "%s: unable to find ARM glue '%s' for `%s'"
 msgstr ""
 
-#: coff-arm.c:1391 coff-arm.c:1486 elf32-arm.h:887 elf32-arm.h:991
+#: coff-arm.c:1391 coff-arm.c:1486 elf32-arm.h:888 elf32-arm.h:992
 #, c-format
 msgid "%s(%s): warning: interworking not enabled."
 msgstr ""
 
-#: coff-arm.c:1395 elf32-arm.h:994
+#: coff-arm.c:1395 elf32-arm.h:995
 #, c-format
 msgid "  first occurrence: %s: arm call to thumb"
 msgstr ""
 
-#: coff-arm.c:1490 elf32-arm.h:890
+#: coff-arm.c:1490 elf32-arm.h:891
 #, c-format
 msgid "  first occurrence: %s: thumb call to arm"
 msgstr ""
@@ -228,100 +229,100 @@ msgstr ""
 msgid "  consider relinking with --support-old-code enabled"
 msgstr ""
 
-#: coff-arm.c:1785 coff-tic80.c:686 cofflink.c:3031
+#: coff-arm.c:1785 coff-tic80.c:686 cofflink.c:3034
 #, c-format
 msgid "%s: bad reloc address 0x%lx in section `%s'"
 msgstr ""
 
-#: coff-arm.c:2127
+#: coff-arm.c:2129
 #, c-format
 msgid "%s: illegal symbol index in reloc: %d"
 msgstr ""
 
-#: coff-arm.c:2255
+#: coff-arm.c:2257
 #, c-format
 msgid "ERROR: %s is compiled for APCS-%d, whereas %s is compiled for APCS-%d"
 msgstr ""
 
-#: coff-arm.c:2270 elf32-arm.h:2297
+#: coff-arm.c:2272 elf32-arm.h:2298
 #, c-format
 msgid ""
 "ERROR: %s passes floats in float registers, whereas %s passes them in "
 "integer registers"
 msgstr ""
 
-#: coff-arm.c:2273 elf32-arm.h:2302
+#: coff-arm.c:2275 elf32-arm.h:2303
 #, c-format
 msgid ""
 "ERROR: %s passes floats in integer registers, whereas %s passes them in "
 "float registers"
 msgstr ""
 
-#: coff-arm.c:2288
+#: coff-arm.c:2290
 #, c-format
 msgid ""
 "ERROR: %s is compiled as position independent code, whereas target %s is "
 "absolute position"
 msgstr ""
 
-#: coff-arm.c:2291
+#: coff-arm.c:2293
 #, c-format
 msgid ""
 "ERROR: %s is compiled as absolute position code, whereas target %s is "
 "position independent"
 msgstr ""
 
-#: coff-arm.c:2320 elf32-arm.h:2358
+#: coff-arm.c:2322 elf32-arm.h:2359
 #, c-format
 msgid "Warning: %s supports interworking, whereas %s does not"
 msgstr ""
 
-#: coff-arm.c:2323 elf32-arm.h:2365
+#: coff-arm.c:2325 elf32-arm.h:2366
 #, c-format
 msgid "Warning: %s does not support interworking, whereas %s does"
 msgstr ""
 
-#: coff-arm.c:2350
+#: coff-arm.c:2352
 #, c-format
 msgid "private flags = %x:"
 msgstr ""
 
-#: coff-arm.c:2358 elf32-arm.h:2418
+#: coff-arm.c:2360 elf32-arm.h:2419
 msgid " [floats passed in float registers]"
 msgstr ""
 
-#: coff-arm.c:2360
+#: coff-arm.c:2362
 msgid " [floats passed in integer registers]"
 msgstr ""
 
-#: coff-arm.c:2363 elf32-arm.h:2421
+#: coff-arm.c:2365 elf32-arm.h:2422
 msgid " [position independent]"
 msgstr ""
 
-#: coff-arm.c:2365
+#: coff-arm.c:2367
 msgid " [absolute position]"
 msgstr ""
 
-#: coff-arm.c:2369
+#: coff-arm.c:2371
 msgid " [interworking flag not initialised]"
 msgstr ""
 
-#: coff-arm.c:2371
+#: coff-arm.c:2373
 msgid " [interworking supported]"
 msgstr ""
 
-#: coff-arm.c:2373
+#: coff-arm.c:2375
 msgid " [interworking not supported]"
 msgstr ""
 
-#: coff-arm.c:2421 elf32-arm.h:2124
+#: coff-arm.c:2423 elf32-arm.h:2125
 #, c-format
 msgid ""
 "Warning: Not setting interworking flag of %s since it has already been "
 "specified as non-interworking"
 msgstr ""
 
-#: coff-arm.c:2425 elf32-arm.h:2128
+#: coff-arm.c:2427 elf32-arm.h:2129
 #, c-format
 msgid "Warning: Clearing the interworking flag of %s due to outside request"
 msgstr ""
@@ -348,17 +349,17 @@ msgstr ""
 msgid "reloc not properly aligned"
 msgstr ""
 
-#: coff-rs6000.c:2766
+#: coff-rs6000.c:2760
 #, c-format
 msgid "%s: unsupported relocation type 0x%02x"
 msgstr ""
 
-#: coff-rs6000.c:2859
+#: coff-rs6000.c:2853
 #, c-format
 msgid "%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"
 msgstr ""
 
-#: coff-rs6000.c:3590 coff64-rs6000.c:2091
+#: coff-rs6000.c:3586 coff64-rs6000.c:2080
 #, c-format
 msgid "%s: symbol `%s' has unrecognized smclas %d"
 msgstr ""
@@ -368,7 +369,7 @@ msgstr ""
 msgid "Unrecognized reloc type 0x%x"
 msgstr ""
 
-#: coff-tic54x.c:390 coffcode.h:4974
+#: coff-tic54x.c:390 coffcode.h:4981
 #, c-format
 msgid "%s: warning: illegal symbol index %ld in relocs"
 msgstr ""
@@ -388,52 +389,52 @@ msgstr ""
 msgid "Unrecognized TI COFF target id '0x%x'"
 msgstr ""
 
-#: coffcode.h:4365
+#: coffcode.h:4372
 #, c-format
 msgid "%s: warning: illegal symbol index %ld in line numbers"
 msgstr ""
 
-#: coffcode.h:4379
+#: coffcode.h:4386
 #, c-format
 msgid "%s: warning: duplicate line number information for `%s'"
 msgstr ""
 
-#: coffcode.h:4736
+#: coffcode.h:4743
 #, c-format
 msgid "%s: Unrecognized storage class %d for %s symbol `%s'"
 msgstr ""
 
-#: coffcode.h:4867
+#: coffcode.h:4874
 #, c-format
 msgid "warning: %s: local symbol `%s' has no section"
 msgstr ""
 
-#: coffcode.h:5012
+#: coffcode.h:5019
 #, c-format
 msgid "%s: illegal relocation type %d at address 0x%lx"
 msgstr ""
 
-#: coffgen.c:1661
+#: coffgen.c:1668
 #, c-format
 msgid "%s: bad string table size %lu"
 msgstr ""
 
-#: cofflink.c:534 elflink.h:1912
+#: cofflink.c:534 elflink.h:1930
 #, c-format
 msgid "Warning: type of symbol `%s' changed from %d to %d in %s"
 msgstr ""
 
-#: cofflink.c:2321
+#: cofflink.c:2324
 #, c-format
 msgid "%s: relocs in section `%s', but it has no contents"
 msgstr ""
 
-#: cofflink.c:2664 coffswap.h:877
+#: cofflink.c:2667 coffswap.h:877
 #, c-format
 msgid "%s: %s: reloc overflow: 0x%lx > 0xffff"
 msgstr ""
 
-#: cofflink.c:2673 coffswap.h:864
+#: cofflink.c:2676 coffswap.h:864
 #, c-format
 msgid "%s: warning: %s: line number overflow: 0x%lx > 0xffff"
 msgstr ""
@@ -460,144 +461,144 @@ msgid ""
 "(%lu)."
 msgstr ""
 
-#: dwarf2.c:757
+#: dwarf2.c:760
 #, c-format
 msgid "Dwarf Error: Invalid or unhandled FORM value: %u."
 msgstr ""
 
-#: dwarf2.c:852
+#: dwarf2.c:924
 msgid "Dwarf Error: mangled line number section (bad file number)."
 msgstr ""
 
-#: dwarf2.c:938
+#: dwarf2.c:1016
 msgid "Dwarf Error: Can't find .debug_line section."
 msgstr ""
 
-#: dwarf2.c:961
+#: dwarf2.c:1039
 #, c-format
 msgid ""
 "Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%"
 "lu)."
 msgstr ""
 
-#: dwarf2.c:1159
+#: dwarf2.c:1245
 msgid "Dwarf Error: mangled line number section."
 msgstr ""
 
-#: dwarf2.c:1355 dwarf2.c:1566
+#: dwarf2.c:1454 dwarf2.c:1665
 #, c-format
 msgid "Dwarf Error: Could not find abbrev number %u."
 msgstr ""
 
-#: dwarf2.c:1527
+#: dwarf2.c:1626
 #, c-format
 msgid ""
 "Dwarf Error: found dwarf version '%u', this reader only handles version 2 "
 "information."
 msgstr ""
 
-#: dwarf2.c:1534
+#: dwarf2.c:1633
 #, c-format
 msgid ""
 "Dwarf Error: found address size '%u', this reader can not handle sizes "
 "greater than '%u'."
 msgstr ""
 
-#: dwarf2.c:1557
+#: dwarf2.c:1656
 #, c-format
 msgid "Dwarf Error: Bad abbrev number: %u."
 msgstr ""
 
-#: ecoff.c:1318
+#: ecoff.c:1320
 #, c-format
 msgid "Unknown basic type %d"
 msgstr ""
 
-#: ecoff.c:1578
+#: ecoff.c:1580
 #, c-format
 msgid ""
 "\n"
 "      End+1 symbol: %ld"
 msgstr ""
 
-#: ecoff.c:1585 ecoff.c:1588
+#: ecoff.c:1587 ecoff.c:1590
 #, c-format
 msgid ""
 "\n"
 "      First symbol: %ld"
 msgstr ""
 
-#: ecoff.c:1600
+#: ecoff.c:1602
 #, c-format
 msgid ""
 "\n"
 "      End+1 symbol: %-7ld   Type:  %s"
 msgstr ""
 
-#: ecoff.c:1607
+#: ecoff.c:1609
 #, c-format
 msgid ""
 "\n"
 "      Local symbol: %ld"
 msgstr ""
 
-#: ecoff.c:1615
+#: ecoff.c:1617
 #, c-format
 msgid ""
 "\n"
 "      struct; End+1 symbol: %ld"
 msgstr ""
 
-#: ecoff.c:1620
+#: ecoff.c:1622
 #, c-format
 msgid ""
 "\n"
 "      union; End+1 symbol: %ld"
 msgstr ""
 
-#: ecoff.c:1625
+#: ecoff.c:1627
 #, c-format
 msgid ""
 "\n"
 "      enum; End+1 symbol: %ld"
 msgstr ""
 
-#: ecoff.c:1631
+#: ecoff.c:1633
 #, c-format
 msgid ""
 "\n"
 "      Type: %s"
 msgstr ""
 
-#: elf-hppa.h:1476 elf-hppa.h:1509 elf32-ppc.c:3091 elf32-sh.c:4213
+#: elf-hppa.h:1476 elf-hppa.h:1509 elf32-ppc.c:3091 elf32-sh.c:4537
 #: elf64-sh64.c:1659
 #, c-format
 msgid ""
 "%s: warning: unresolvable relocation against symbol `%s' from %s section"
 msgstr ""
 
-#: elf-m10200.c:446 elf-m10300.c:656 elf32-arm.h:2084 elf32-avr.c:833
+#: elf-m10200.c:446 elf-m10300.c:656 elf32-arm.h:2085 elf32-avr.c:833
 #: elf32-cris.c:1403 elf32-d10v.c:481 elf32-fr30.c:635 elf32-frv.c:809
-#: elf32-h8300.c:548 elf32-i860.c:1031 elf32-m32r.c:1278 elf32-openrisc.c:439
+#: elf32-h8300.c:548 elf32-i860.c:1031 elf32-m32r.c:1280 elf32-openrisc.c:439
 #: elf32-v850.c:1691 elf32-xstormy16.c:933 elf64-mmix.c:1302
 msgid "internal error: out of range error"
 msgstr ""
 
-#: elf-m10200.c:450 elf-m10300.c:660 elf32-arm.h:2088 elf32-avr.c:837
+#: elf-m10200.c:450 elf-m10300.c:660 elf32-arm.h:2089 elf32-avr.c:837
 #: elf32-cris.c:1407 elf32-d10v.c:485 elf32-fr30.c:639 elf32-frv.c:813
-#: elf32-h8300.c:552 elf32-i860.c:1035 elf32-m32r.c:1282 elf32-openrisc.c:443
-#: elf32-v850.c:1695 elf32-xstormy16.c:937 elf64-mmix.c:1306 elfxx-mips.c:5264
+#: elf32-h8300.c:552 elf32-i860.c:1035 elf32-m32r.c:1284 elf32-openrisc.c:443
+#: elf32-v850.c:1695 elf32-xstormy16.c:937 elf64-mmix.c:1306 elfxx-mips.c:5258
 msgid "internal error: unsupported relocation error"
 msgstr ""
 
-#: elf-m10200.c:454 elf-m10300.c:664 elf32-arm.h:2092 elf32-d10v.c:489
-#: elf32-h8300.c:556 elf32-m32r.c:1286
+#: elf-m10200.c:454 elf-m10300.c:664 elf32-arm.h:2093 elf32-d10v.c:489
+#: elf32-h8300.c:556 elf32-m32r.c:1288
 msgid "internal error: dangerous error"
 msgstr ""
 
-#: elf-m10200.c:458 elf-m10300.c:668 elf32-arm.h:2096 elf32-avr.c:845
+#: elf-m10200.c:458 elf-m10300.c:668 elf32-arm.h:2097 elf32-avr.c:845
 #: elf32-cris.c:1415 elf32-d10v.c:493 elf32-fr30.c:647 elf32-frv.c:821
-#: elf32-h8300.c:560 elf32-i860.c:1043 elf32-m32r.c:1290 elf32-openrisc.c:451
+#: elf32-h8300.c:560 elf32-i860.c:1043 elf32-m32r.c:1292 elf32-openrisc.c:451
 #: elf32-v850.c:1715 elf32-xstormy16.c:945 elf64-mmix.c:1314
 msgid "internal error: unknown error"
 msgstr ""
@@ -646,177 +647,177 @@ msgstr ""
 msgid "  required from %s:\n"
 msgstr ""
 
-#: elf.c:1902
+#: elf.c:1904
 #, c-format
 msgid "%s: invalid link %lu for reloc section %s (index %u)"
 msgstr ""
 
-#: elf.c:3603
+#: elf.c:3619
 #, c-format
 msgid "%s: Not enough room for program headers (allocated %u, need %u)"
 msgstr ""
 
-#: elf.c:3708
+#: elf.c:3724
 #, c-format
 msgid "%s: Not enough room for program headers, try linking with -N"
 msgstr ""
 
-#: elf.c:3833
+#: elf.c:3849
 #, c-format
 msgid ""
 "Error: First section in segment (%s) starts at 0x%x whereas the segment "
 "starts at 0x%x"
 msgstr ""
 
-#: elf.c:4148
+#: elf.c:4164
 #, c-format
 msgid "%s: warning: allocated section `%s' not in segment"
 msgstr ""
 
-#: elf.c:4472
+#: elf.c:4488
 #, c-format
 msgid "%s: symbol `%s' required but not present"
 msgstr ""
 
-#: elf.c:4749
+#: elf.c:4765
 #, c-format
 msgid "%s: warning: Empty loadable segment detected, is this intentional ?\n"
 msgstr ""
 
-#: elf.c:6193
+#: elf.c:6213
 #, c-format
 msgid "%s: unsupported relocation type %s"
 msgstr ""
 
-#: elf32-arm.h:1221
+#: elf32-arm.h:1222
 #, c-format
 msgid "%s: Warning: Arm BLX instruction targets Arm function '%s'."
 msgstr ""
 
-#: elf32-arm.h:1417
+#: elf32-arm.h:1418
 #, c-format
 msgid "%s: Warning: Thumb BLX instruction targets thumb function '%s'."
 msgstr ""
 
-#: elf32-arm.h:1914 elf32-sh.c:4125
+#: elf32-arm.h:1915 elf32-sh.c:4444
 #, c-format
 msgid "%s(%s+0x%lx): %s relocation against SEC_MERGE section"
 msgstr ""
 
-#: elf32-arm.h:2008
+#: elf32-arm.h:2009
 #, c-format
 msgid ""
 "%s: warning: unresolvable relocation %d against symbol `%s' from %s section"
 msgstr ""
 
-#: elf32-arm.h:2176
+#: elf32-arm.h:2177
 #, c-format
 msgid ""
 "Warning: Clearing the interworking flag of %s because non-interworking code "
 "in %s has been linked with it"
 msgstr ""
 
-#: elf32-arm.h:2271
+#: elf32-arm.h:2272
 #, c-format
 msgid ""
 "ERROR: %s is compiled for EABI version %d, whereas %s is compiled for "
 "version %d"
 msgstr ""
 
-#: elf32-arm.h:2285
+#: elf32-arm.h:2286
 #, c-format
 msgid "ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"
 msgstr ""
 
-#: elf32-arm.h:2313
+#: elf32-arm.h:2314
 #, c-format
 msgid "ERROR: %s uses VFP instructions, whereas %s uses FPA instructions"
 msgstr ""
 
-#: elf32-arm.h:2318
+#: elf32-arm.h:2319
 #, c-format
 msgid "ERROR: %s uses FPA instructions, whereas %s uses VFP instructions"
 msgstr ""
 
-#: elf32-arm.h:2338
+#: elf32-arm.h:2339
 #, c-format
 msgid "ERROR: %s uses software FP, whereas %s uses hardware FP"
 msgstr ""
 
-#: elf32-arm.h:2343
+#: elf32-arm.h:2344
 #, c-format
 msgid "ERROR: %s uses hardware FP, whereas %s uses software FP"
 msgstr ""
 
 #. Ignore init flag - it may not be set, despite the flags field
 #. containing valid data.
-#: elf32-arm.h:2396 elf32-cris.c:2988 elf32-m68k.c:410 elf32-vax.c:543
-#: elfxx-mips.c:7756
+#: elf32-arm.h:2397 elf32-cris.c:2989 elf32-m68k.c:410 elf32-vax.c:548
+#: elfxx-mips.c:7760
 #, c-format
 msgid "private flags = %lx:"
 msgstr ""
 
-#: elf32-arm.h:2405
+#: elf32-arm.h:2406
 msgid " [interworking enabled]"
 msgstr ""
 
-#: elf32-arm.h:2413
+#: elf32-arm.h:2414
 msgid " [VFP float format]"
 msgstr ""
 
-#: elf32-arm.h:2415
+#: elf32-arm.h:2416
 msgid " [FPA float format]"
 msgstr ""
 
-#: elf32-arm.h:2424
+#: elf32-arm.h:2425
 msgid " [new ABI]"
 msgstr ""
 
-#: elf32-arm.h:2427
+#: elf32-arm.h:2428
 msgid " [old ABI]"
 msgstr ""
 
-#: elf32-arm.h:2430
+#: elf32-arm.h:2431
 msgid " [software FP]"
 msgstr ""
 
-#: elf32-arm.h:2438
+#: elf32-arm.h:2439
 msgid " [Version1 EABI]"
 msgstr ""
 
-#: elf32-arm.h:2441 elf32-arm.h:2452
+#: elf32-arm.h:2442 elf32-arm.h:2453
 msgid " [sorted symbol table]"
 msgstr ""
 
-#: elf32-arm.h:2443 elf32-arm.h:2454
+#: elf32-arm.h:2444 elf32-arm.h:2455
 msgid " [unsorted symbol table]"
 msgstr ""
 
-#: elf32-arm.h:2449
+#: elf32-arm.h:2450
 msgid " [Version2 EABI]"
 msgstr ""
 
-#: elf32-arm.h:2457
+#: elf32-arm.h:2458
 msgid " [dynamic symbols use segment index]"
 msgstr ""
 
-#: elf32-arm.h:2460
+#: elf32-arm.h:2461
 msgid " [mapping symbols precede others]"
 msgstr ""
 
-#: elf32-arm.h:2467
+#: elf32-arm.h:2468
 msgid " <EABI version unrecognised>"
 msgstr ""
 
-#: elf32-arm.h:2474
+#: elf32-arm.h:2475
 msgid " [relocatable executable]"
 msgstr ""
 
-#: elf32-arm.h:2477
+#: elf32-arm.h:2478
 msgid " [has entry point]"
 msgstr ""
 
-#: elf32-arm.h:2482
+#: elf32-arm.h:2483
 msgid "<Unrecognised flag bits set>"
 msgstr ""
 
@@ -877,16 +878,16 @@ msgid ""
 "  relocation %s should not be used in a shared object; recompile with -fPIC"
 msgstr ""
 
-#: elf32-cris.c:2991
+#: elf32-cris.c:2992
 msgid " [symbols have a _ prefix]"
 msgstr ""
 
-#: elf32-cris.c:3030
+#: elf32-cris.c:3031
 #, c-format
 msgid "%s: uses _-prefixed symbols, but writing file with non-prefixed symbols"
 msgstr ""
 
-#: elf32-cris.c:3031
+#: elf32-cris.c:3032
 #, c-format
 msgid "%s: uses non-prefixed symbols, but writing file with _-prefixed symbols"
 msgstr ""
@@ -919,122 +920,117 @@ msgstr ""
 msgid "%s: Relocations in generic ELF (EM: %d)"
 msgstr ""
 
-#: elf32-hppa.c:671 elf64-ppc.c:2323
+#: elf32-hppa.c:672 elf64-ppc.c:2324
 #, c-format
 msgid "%s: cannot create stub entry %s"
 msgstr ""
 
-#: elf32-hppa.c:956 elf32-hppa.c:3555
+#: elf32-hppa.c:957 elf32-hppa.c:3557
 #, c-format
 msgid "%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"
 msgstr ""
 
-#: elf32-hppa.c:1338 elf64-x86-64.c:673
+#: elf32-hppa.c:1340 elf64-x86-64.c:675
 #, c-format
 msgid ""
 "%s: relocation %s can not be used when making a shared object; recompile "
 "with -fPIC"
 msgstr ""
 
-#: elf32-hppa.c:1358
+#: elf32-hppa.c:1360
 #, c-format
 msgid ""
 "%s: relocation %s should not be used when making a shared object; recompile "
 "with -fPIC"
 msgstr ""
 
-#: elf32-hppa.c:1551
+#: elf32-hppa.c:1553
 #, c-format
 msgid "Could not find relocation section for %s"
 msgstr ""
 
-#: elf32-hppa.c:2855
+#: elf32-hppa.c:2857
 #, c-format
 msgid "%s: duplicate export stub %s"
 msgstr ""
 
-#: elf32-hppa.c:3433
+#: elf32-hppa.c:3435
 #, c-format
 msgid "%s(%s+0x%lx): fixing %s"
 msgstr ""
 
-#: elf32-hppa.c:4080
+#: elf32-hppa.c:4082
 #, c-format
 msgid "%s(%s+0x%lx): cannot handle %s for %s"
 msgstr ""
 
-#: elf32-hppa.c:4393
+#: elf32-hppa.c:4395
 msgid ".got section not immediately after .plt section"
 msgstr ""
 
-#: elf32-i386.c:379
+#: elf32-i386.c:401
 #, c-format
 msgid "%s: invalid relocation type %d"
 msgstr ""
 
-#: elf32-i386.c:876 elf32-s390.c:649 elf64-s390.c:595 elf64-x86-64.c:591
+#: elf32-i386.c:916 elf32-s390.c:651 elf64-s390.c:597 elf64-x86-64.c:593
 #, c-format
 msgid "%s: bad symbol index: %d"
 msgstr ""
 
-#: elf32-i386.c:948
+#: elf32-i386.c:1025
 #, c-format
 msgid "%s: `%s' accessed both as normal and thread local symbol"
 msgstr ""
 
-#: elf32-i386.c:1072 elf32-s390.c:808 elf64-ppc.c:2827 elf64-s390.c:759
-#: elf64-x86-64.c:761
+#: elf32-i386.c:1137 elf32-s390.c:810 elf64-ppc.c:2829 elf64-s390.c:761
+#: elf64-x86-64.c:763
 #, c-format
 msgid "%s: bad relocation section name `%s'"
 msgstr ""
 
-#: elf32-i386.c:1159 elf64-alpha.c:4768
-#, c-format
-msgid "%s: TLS local exec code cannot be linked into shared objects"
-msgstr ""
-
-#: elf32-i386.c:2747 elf32-s390.c:1981 elf32-sparc.c:1571 elf64-ppc.c:5918
-#: elf64-s390.c:1945 elf64-sparc.c:2578 elf64-x86-64.c:1948
+#: elf32-i386.c:2990 elf32-s390.c:1983 elf32-sparc.c:1572 elf64-ppc.c:5941
+#: elf64-s390.c:1947 elf64-sparc.c:2578 elf64-x86-64.c:1950
 #, c-format
 msgid "%s(%s+0x%lx): unresolvable relocation against symbol `%s'"
 msgstr ""
 
-#: elf32-i386.c:2784 elf32-s390.c:2019 elf64-ppc.c:5977 elf64-s390.c:1983
-#: elf64-x86-64.c:1986
+#: elf32-i386.c:3029 elf32-s390.c:2021 elf64-ppc.c:6000 elf64-s390.c:1985
+#: elf64-x86-64.c:1988
 #, c-format
 msgid "%s(%s+0x%lx): reloc against `%s': error %d"
 msgstr ""
 
-#: elf32-m32r.c:924
+#: elf32-m32r.c:926
 msgid "SDA relocation when _SDA_BASE_ not defined"
 msgstr ""
 
-#: elf32-ia64.c:3687 elf32-m32r.c:1013 elf32-ppc.c:2987 elf64-alpha.c:4185
-#: elf64-alpha.c:4313 elf64-ia64.c:3687
+#: elf32-m32r.c:1015 elf32-ppc.c:2987 elf64-alpha.c:4186 elf64-alpha.c:4314
+#: elf32-ia64.c:3693 elf64-ia64.c:3693
 #, c-format
 msgid "%s: unknown relocation type %d"
 msgstr ""
 
-#: elf32-m32r.c:1221
+#: elf32-m32r.c:1223
 #, c-format
 msgid "%s: The target (%s) of an %s relocation is in the wrong section (%s)"
 msgstr ""
 
-#: elf32-m32r.c:1947
+#: elf32-m32r.c:1949
 #, c-format
 msgid "%s: Instruction set mismatch with previous modules"
 msgstr ""
 
-#: elf32-m32r.c:1970
+#: elf32-m32r.c:1972
 #, c-format
 msgid "private flags = %lx"
 msgstr ""
 
-#: elf32-m32r.c:1975
+#: elf32-m32r.c:1977
 msgid ": m32r instructions"
 msgstr ""
 
-#: elf32-m32r.c:1976
+#: elf32-m32r.c:1978
 msgid ": m32rx instructions"
 msgstr ""
 
@@ -1077,7 +1073,7 @@ msgid ""
 "%s: compiled normally and linked with modules compiled with -mrelocatable"
 msgstr ""
 
-#: elf32-ppc.c:1494 elf64-sparc.c:2989 elfxx-mips.c:7713
+#: elf32-ppc.c:1494 elf64-sparc.c:2990 elfxx-mips.c:7717
 #, c-format
 msgid "%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"
 msgstr ""
@@ -1092,67 +1088,67 @@ msgstr ""
 msgid "%s: relocation %s cannot be used when making a shared object"
 msgstr ""
 
-#: elf32-ppc.c:3126 elf64-ppc.c:5473
+#: elf32-ppc.c:3126 elf64-ppc.c:5496
 #, c-format
 msgid "%s: unknown relocation type %d for symbol %s"
 msgstr ""
 
-#: elf32-ppc.c:3482 elf32-ppc.c:3503 elf32-ppc.c:3553
+#: elf32-ppc.c:3489 elf32-ppc.c:3510 elf32-ppc.c:3560
 #, c-format
 msgid ""
 "%s: The target (%s) of a %s relocation is in the wrong output section (%s)"
 msgstr ""
 
-#: elf32-ppc.c:3619
+#: elf32-ppc.c:3626
 #, c-format
 msgid "%s: Relocation %s is not yet supported for symbol %s."
 msgstr ""
 
-#: elf32-sh.c:1964
+#: elf32-sh.c:1973
 #, c-format
 msgid "%s: 0x%lx: warning: bad R_SH_USES offset"
 msgstr ""
 
-#: elf32-sh.c:1976
+#: elf32-sh.c:1985
 #, c-format
 msgid "%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"
 msgstr ""
 
-#: elf32-sh.c:1993
+#: elf32-sh.c:2002
 #, c-format
 msgid "%s: 0x%lx: warning: bad R_SH_USES load offset"
 msgstr ""
 
-#: elf32-sh.c:2008
+#: elf32-sh.c:2017
 #, c-format
 msgid "%s: 0x%lx: warning: could not find expected reloc"
 msgstr ""
 
-#: elf32-sh.c:2036
+#: elf32-sh.c:2045
 #, c-format
 msgid "%s: 0x%lx: warning: symbol in unexpected section"
 msgstr ""
 
-#: elf32-sh.c:2153
+#: elf32-sh.c:2162
 #, c-format
 msgid "%s: 0x%lx: warning: could not find expected COUNT reloc"
 msgstr ""
 
-#: elf32-sh.c:2162
+#: elf32-sh.c:2171
 #, c-format
 msgid "%s: 0x%lx: warning: bad count"
 msgstr ""
 
-#: elf32-sh.c:2550 elf32-sh.c:2926
+#: elf32-sh.c:2559 elf32-sh.c:2935
 #, c-format
 msgid "%s: 0x%lx: fatal: reloc overflow while relaxing"
 msgstr ""
 
-#: elf32-sh.c:4073 elf64-sh64.c:1576
+#: elf32-sh.c:4392 elf64-sh64.c:1576
 msgid "Unexpected STO_SH5_ISA32 on local symbol is not handled"
 msgstr ""
 
-#: elf32-sh.c:4284
+#: elf32-sh.c:4611
 #, c-format
 msgid "%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"
 msgstr ""
@@ -1172,50 +1168,50 @@ msgstr ""
 msgid "%s: object size does not match that of target %s"
 msgstr ""
 
-#: elf32-sh64.c:440 elf64-sh64.c:2941
+#: elf32-sh64.c:443 elf64-sh64.c:2944
 #, c-format
 msgid "%s: encountered datalabel symbol in input"
 msgstr ""
 
-#: elf32-sh64.c:523
+#: elf32-sh64.c:526
 msgid "PTB mismatch: a SHmedia address (bit 0 == 1)"
 msgstr ""
 
-#: elf32-sh64.c:526
+#: elf32-sh64.c:529
 msgid "PTA mismatch: a SHcompact address (bit 0 == 0)"
 msgstr ""
 
-#: elf32-sh64.c:544
+#: elf32-sh64.c:547
 #, c-format
 msgid "%s: GAS error: unexpected PTB insn with R_SH_PT_16"
 msgstr ""
 
-#: elf32-sh64.c:593 elf64-sh64.c:1703
+#: elf32-sh64.c:596 elf64-sh64.c:1703
 #, c-format
 msgid "%s: error: unaligned relocation type %d at %08x reloc %08x\n"
 msgstr ""
 
-#: elf32-sh64.c:677
+#: elf32-sh64.c:680
 #, c-format
 msgid "%s: could not write out added .cranges entries"
 msgstr ""
 
-#: elf32-sh64.c:739
+#: elf32-sh64.c:742
 #, c-format
 msgid "%s: could not write out sorted .cranges entries"
 msgstr ""
 
-#: elf32-sparc.c:1535 elf64-sparc.c:2224
+#: elf32-sparc.c:1536 elf64-sparc.c:2224
 #, c-format
 msgid "%s: probably compiled without -fPIC?"
 msgstr ""
 
-#: elf32-sparc.c:2002
+#: elf32-sparc.c:2010
 #, c-format
 msgid "%s: compiled for a 64 bit system and target is 32 bit"
 msgstr ""
 
-#: elf32-sparc.c:2016
+#: elf32-sparc.c:2024
 #, c-format
 msgid "%s: linking little endian files with big endian files"
 msgstr ""
@@ -1287,41 +1283,41 @@ msgstr ""
 msgid "v850ea architecture"
 msgstr ""
 
-#: elf32-vax.c:546
+#: elf32-vax.c:551
 msgid " [nonpic]"
 msgstr ""
 
-#: elf32-vax.c:549
+#: elf32-vax.c:554
 msgid " [d-float]"
 msgstr ""
 
-#: elf32-vax.c:552
+#: elf32-vax.c:557
 msgid " [g-float]"
 msgstr ""
 
-#: elf32-vax.c:674
+#: elf32-vax.c:665
 #, c-format
 msgid ""
 "%s: warning: GOT addend of %ld to `%s' does not match previous GOT addend of "
 "%ld"
 msgstr ""
 
-#: elf32-vax.c:1679
+#: elf32-vax.c:1687
 #, c-format
 msgid "%s: warning: PLT addend of %d to `%s' from %s section ignored"
 msgstr ""
 
-#: elf32-vax.c:1814
+#: elf32-vax.c:1822
 #, c-format
 msgid "%s: warning: %s relocation against symbol `%s' from %s section"
 msgstr ""
 
-#: elf32-vax.c:1820
+#: elf32-vax.c:1828
 #, c-format
 msgid "%s: warning: %s relocation to 0x%x from %s section"
 msgstr ""
 
-#: elf32-ia64.c:2280 elf32-xstormy16.c:414 elf64-ia64.c:2280
+#: elf32-xstormy16.c:414 elf32-ia64.c:2286 elf64-ia64.c:2286
 msgid "non-zero addend in @fptr reloc"
 msgstr ""
 
@@ -1329,46 +1325,51 @@ msgstr ""
 msgid "GPDISP relocation did not find ldah and lda instructions"
 msgstr ""
 
-#: elf64-alpha.c:3675
+#: elf64-alpha.c:3676
 #, c-format
 msgid "%s: .got subsegment exceeds 64K (size %d)"
 msgstr ""
 
-#: elf64-alpha.c:4498 elf64-alpha.c:4510
+#: elf64-alpha.c:4499 elf64-alpha.c:4511
 #, c-format
 msgid "%s: gp-relative relocation against dynamic symbol %s"
 msgstr ""
 
-#: elf64-alpha.c:4536 elf64-alpha.c:4676
+#: elf64-alpha.c:4537 elf64-alpha.c:4677
 #, c-format
 msgid "%s: pc-relative relocation against dynamic symbol %s"
 msgstr ""
 
-#: elf64-alpha.c:4564
+#: elf64-alpha.c:4565
 #, c-format
 msgid "%s: change in gp: BRSGP %s"
 msgstr ""
 
-#: elf64-alpha.c:4589
+#: elf64-alpha.c:4590
 msgid "<unknown>"
 msgstr ""
 
-#: elf64-alpha.c:4594
+#: elf64-alpha.c:4595
 #, c-format
 msgid "%s: !samegp reloc against symbol without .prologue: %s"
 msgstr ""
 
-#: elf64-alpha.c:4639
+#: elf64-alpha.c:4640
 #, c-format
 msgid "%s: unhandled dynamic relocation against %s"
 msgstr ""
 
-#: elf64-alpha.c:4752
+#: elf64-alpha.c:4753
 #, c-format
 msgid "%s: dtp-relative relocation against dynamic symbol %s"
 msgstr ""
 
-#: elf64-alpha.c:4775
+#: elf64-alpha.c:4769
+#, c-format
+msgid "%s: TLS local exec code cannot be linked into shared objects"
+msgstr ""
+
+#: elf64-alpha.c:4776
 #, c-format
 msgid "%s: tp-relative relocation against dynamic symbol %s"
 msgstr ""
@@ -1447,46 +1448,46 @@ msgstr ""
 msgid "%s: compiled for a little endian system and target is big endian"
 msgstr ""
 
-#: elf64-ppc.c:3610
+#: elf64-ppc.c:3614
 #, c-format
 msgid "%s: unexpected reloc type %u in .opd section"
 msgstr ""
 
-#: elf64-ppc.c:3630
+#: elf64-ppc.c:3634
 #, c-format
 msgid "%s: .opd is not a regular array of opd entries"
 msgstr ""
 
-#: elf64-ppc.c:3672
+#: elf64-ppc.c:3676
 #, c-format
 msgid "%s: undefined sym `%s' in .opd section"
 msgstr ""
 
-#: elf64-ppc.c:4397
+#: elf64-ppc.c:4421
 #, c-format
 msgid "can't find branch stub `%s'"
 msgstr ""
 
-#: elf64-ppc.c:4436 elf64-ppc.c:4501
+#: elf64-ppc.c:4460 elf64-ppc.c:4504
 #, c-format
 msgid "linkage table error against `%s'"
 msgstr ""
 
-#: elf64-ppc.c:4573
+#: elf64-ppc.c:4576
 #, c-format
 msgid "can't build branch stub `%s'"
 msgstr ""
 
-#: elf64-ppc.c:5179
+#: elf64-ppc.c:5202
 msgid "stubs don't match calculated size"
 msgstr ""
 
-#: elf64-ppc.c:5828
+#: elf64-ppc.c:5851
 #, c-format
 msgid "%s: Relocation %s is not supported for symbol %s."
 msgstr ""
 
-#: elf64-ppc.c:5872
+#: elf64-ppc.c:5895
 #, c-format
 msgid "%s: error: relocation %s not a multiple of 4"
 msgstr ""
@@ -1516,7 +1517,7 @@ msgstr ""
 msgid "Symbol `%s' has differing types: %s in %s, previously REGISTER in %s"
 msgstr ""
 
-#: elf64-sparc.c:2970
+#: elf64-sparc.c:2971
 #, c-format
 msgid "%s: linking UltraSPARC specific with HAL specific code"
 msgstr ""
@@ -1526,83 +1527,85 @@ msgstr ""
 msgid "%s: version count (%ld) does not match symbol count (%ld)"
 msgstr ""
 
-#: elflink.c:440
+#: elfcode.h:1433
+#, c-format
+msgid "%s(%s): relocation %d has invalid symbol index %ld"
+msgstr ""
+
+#: elflink.c:536
 #, c-format
 msgid "%s: Section %s is too large to add hole of %ld bytes"
 msgstr ""
 
-#: elflink.h:1090
+#: elflink.h:1098
 #, c-format
-msgid "%s: warning: unexpected redefinition of `%s'"
+msgid "%s: warning: unexpected redefinition of indirect versioned symbol `%s'"
 msgstr ""
 
-#: elflink.h:1727
+#: elflink.h:1745
 #, c-format
 msgid "%s: %s: invalid version %u (max %d)"
 msgstr ""
 
-#: elflink.h:1768
+#: elflink.h:1786
 #, c-format
 msgid "%s: %s: invalid needed version %d"
 msgstr ""
 
-#: elflink.h:1890
+#: elflink.h:1908
 #, c-format
 msgid "Warning: size of symbol `%s' changed from %lu to %lu in %s"
 msgstr ""
 
-#: elflink.h:3174
+#: elflink.h:3116
+#, c-format
+msgid "%s: undefined version: %s"
+msgstr ""
+
+#: elflink.h:3182
 #, c-format
 msgid "%s: .preinit_array section is not allowed in DSO"
 msgstr ""
 
-#: elflink.h:4030
+#: elflink.h:4039
 #, c-format
 msgid "warning: type and size of dynamic symbol `%s' are not defined"
 msgstr ""
 
-#: elflink.h:4345
+#: elflink.h:4354
 #, c-format
 msgid "%s: undefined versioned symbol name %s"
 msgstr ""
 
-#: elflink.h:4611 elflink.h:4619 elflink.h:6508 elflink.h:7600
+#: elflink.h:4595 elflink.h:4603 elflink.h:6494 elflink.h:7569
 msgid "Error: out of memory"
 msgstr ""
 
-#: elflink.h:4781
+#: elflink.h:4767
 msgid "Not enough memory to sort relocations"
 msgstr ""
 
-#: elflink.h:5682 elflink.h:5725
+#: elflink.h:5668 elflink.h:5711
 #, c-format
 msgid "%s: could not find output section %s"
 msgstr ""
 
-#: elflink.h:5688
+#: elflink.h:5674
 #, c-format
 msgid "warning: %s section has zero size"
 msgstr ""
 
-#: elflink.h:6275
+#: elflink.h:6261
 #, c-format
 msgid "%s: could not find output section %s for input section %s"
 msgstr ""
 
-#: elflink.h:6486
+#: elflink.h:6472
 #, c-format
 msgid "%s: relocation size mismatch in %s section %s"
 msgstr ""
 
-#: elflink.h:6849
-msgid "warning: relocation against removed section; zeroing"
-msgstr ""
-
-#: elflink.h:6879
-msgid "warning: relocation against removed section"
-msgstr ""
-
-#: elflink.h:6892
+#: elflink.h:6862
 #, c-format
 msgid "local symbols in discarded section %s"
 msgstr ""
@@ -1611,132 +1614,132 @@ msgstr ""
 msgid "static procedure (no name)"
 msgstr ""
 
-#: elfxx-mips.c:1601
+#: elfxx-mips.c:1604
 msgid "not enough GOT space for local GOT entries"
 msgstr ""
 
-#: elfxx-mips.c:2750
+#: elfxx-mips.c:2755
 #, c-format
 msgid "%s: %s+0x%lx: jump to stub routine which is not jal"
 msgstr ""
 
-#: elfxx-mips.c:4270
+#: elfxx-mips.c:4264
 #, c-format
 msgid "%s: Malformed reloc detected for section %s"
 msgstr ""
 
-#: elfxx-mips.c:4348
+#: elfxx-mips.c:4342
 #, c-format
 msgid "%s: CALL16 reloc at 0x%lx not against global symbol"
 msgstr ""
 
-#: elfxx-mips.c:7301
+#: elfxx-mips.c:7296
 #, c-format
 msgid "%s: illegal section name `%s'"
 msgstr ""
 
-#: elfxx-mips.c:7615
+#: elfxx-mips.c:7610
 #, c-format
 msgid "%s: linking PIC files with non-PIC files"
 msgstr ""
 
-#: elfxx-mips.c:7625
+#: elfxx-mips.c:7620
 #, c-format
 msgid "%s: linking abicalls files with non-abicalls files"
 msgstr ""
 
-#: elfxx-mips.c:7654
+#: elfxx-mips.c:7649
 #, c-format
 msgid "%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"
 msgstr ""
 
-#: elfxx-mips.c:7676
+#: elfxx-mips.c:7671
 #, c-format
 msgid "%s: ISA mismatch (%d) with previous modules (%d)"
 msgstr ""
 
-#: elfxx-mips.c:7699
+#: elfxx-mips.c:7694
 #, c-format
 msgid "%s: ABI mismatch: linking %s module with previous %s modules"
 msgstr ""
 
-#: elfxx-mips.c:7759
+#: elfxx-mips.c:7763
 msgid " [abi=O32]"
 msgstr ""
 
-#: elfxx-mips.c:7761
+#: elfxx-mips.c:7765
 msgid " [abi=O64]"
 msgstr ""
 
-#: elfxx-mips.c:7763
+#: elfxx-mips.c:7767
 msgid " [abi=EABI32]"
 msgstr ""
 
-#: elfxx-mips.c:7765
+#: elfxx-mips.c:7769
 msgid " [abi=EABI64]"
 msgstr ""
 
-#: elfxx-mips.c:7767
+#: elfxx-mips.c:7771
 msgid " [abi unknown]"
 msgstr ""
 
-#: elfxx-mips.c:7769
+#: elfxx-mips.c:7773
 msgid " [abi=N32]"
 msgstr ""
 
-#: elfxx-mips.c:7771
+#: elfxx-mips.c:7775
 msgid " [abi=64]"
 msgstr ""
 
-#: elfxx-mips.c:7773
+#: elfxx-mips.c:7777
 msgid " [no abi set]"
 msgstr ""
 
-#: elfxx-mips.c:7776
+#: elfxx-mips.c:7780
 msgid " [mips1]"
 msgstr ""
 
-#: elfxx-mips.c:7778
+#: elfxx-mips.c:7782
 msgid " [mips2]"
 msgstr ""
 
-#: elfxx-mips.c:7780
+#: elfxx-mips.c:7784
 msgid " [mips3]"
 msgstr ""
 
-#: elfxx-mips.c:7782
+#: elfxx-mips.c:7786
 msgid " [mips4]"
 msgstr ""
 
-#: elfxx-mips.c:7784
+#: elfxx-mips.c:7788
 msgid " [mips5]"
 msgstr ""
 
-#: elfxx-mips.c:7786
+#: elfxx-mips.c:7790
 msgid " [mips32]"
 msgstr ""
 
-#: elfxx-mips.c:7788
+#: elfxx-mips.c:7792
 msgid " [mips64]"
 msgstr ""
 
-#: elfxx-mips.c:7790
+#: elfxx-mips.c:7794
 msgid " [unknown ISA]"
 msgstr ""
 
-#: elfxx-mips.c:7793
+#: elfxx-mips.c:7797
 msgid " [mdmx]"
 msgstr ""
 
-#: elfxx-mips.c:7796
+#: elfxx-mips.c:7800
 msgid " [mips16]"
 msgstr ""
 
-#: elfxx-mips.c:7799
+#: elfxx-mips.c:7803
 msgid " [32bitmode]"
 msgstr ""
 
-#: elfxx-mips.c:7801
+#: elfxx-mips.c:7805
 msgid " [not 32bitmode]"
 msgstr ""
 
@@ -1785,52 +1788,52 @@ msgstr ""
 msgid "%s: unexpected type after ATN"
 msgstr ""
 
-#: ihex.c:258
+#: ihex.c:255
 #, c-format
 msgid "%s:%d: unexpected character `%s' in Intel Hex file\n"
 msgstr ""
 
-#: ihex.c:366
+#: ihex.c:363
 #, c-format
 msgid "%s:%u: bad checksum in Intel Hex file (expected %u, found %u)"
 msgstr ""
 
-#: ihex.c:420
+#: ihex.c:417
 #, c-format
 msgid "%s:%u: bad extended address record length in Intel Hex file"
 msgstr ""
 
-#: ihex.c:437
+#: ihex.c:434
 #, c-format
 msgid "%s:%u: bad extended start address length in Intel Hex file"
 msgstr ""
 
-#: ihex.c:454
+#: ihex.c:451
 #, c-format
 msgid "%s:%u: bad extended linear address record length in Intel Hex file"
 msgstr ""
 
-#: ihex.c:471
+#: ihex.c:468
 #, c-format
 msgid "%s:%u: bad extended linear start address length in Intel Hex file"
 msgstr ""
 
-#: ihex.c:488
+#: ihex.c:485
 #, c-format
 msgid "%s:%u: unrecognized ihex type %u in Intel Hex file\n"
 msgstr ""
 
-#: ihex.c:607
+#: ihex.c:610
 #, c-format
 msgid "%s: internal error in ihex_read_section"
 msgstr ""
 
-#: ihex.c:642
+#: ihex.c:645
 #, c-format
 msgid "%s: bad section length in ihex_read_section"
 msgstr ""
 
-#: ihex.c:860
+#: ihex.c:863
 #, c-format
 msgid "%s: address 0x%s out of range for Intel Hex file"
 msgstr ""
@@ -1854,12 +1857,12 @@ msgstr ""
 msgid "Deprecated %s called\n"
 msgstr ""
 
-#: linker.c:1873
+#: linker.c:1875
 #, c-format
 msgid "%s: indirect symbol `%s' to `%s' is a loop"
 msgstr ""
 
-#: linker.c:2776
+#: linker.c:2778
 #, c-format
 msgid "Attempt to do relocateable link with %s input and %s output"
 msgstr ""
@@ -2079,7 +2082,7 @@ msgstr ""
 msgid "%s: size field is zero in Import Library Format header"
 msgstr ""
 
-#: peicode.h:1219
+#: peicode.h:1222
 #, c-format
 msgid "%s: string not null terminated in ILF object file."
 msgstr ""
@@ -2136,7 +2139,7 @@ msgstr ""
 msgid "som_sizeof_headers unimplemented"
 msgstr ""
 
-#: srec.c:301
+#: srec.c:302
 #, c-format
 msgid "%s:%d: Unexpected character `%s' in S-record file\n"
 msgstr ""
@@ -2174,29 +2177,29 @@ msgstr ""
 msgid "Object module NOT error-free !\n"
 msgstr ""
 
-#: vms-misc.c:543
+#: vms-misc.c:541
 #, c-format
 msgid "Stack overflow (%d) in _bfd_vms_push"
 msgstr ""
 
-#: vms-misc.c:561
+#: vms-misc.c:559
 msgid "Stack underflow in _bfd_vms_pop"
 msgstr ""
 
-#: vms-misc.c:919
+#: vms-misc.c:918
 msgid "_bfd_vms_output_counted called with zero bytes"
 msgstr ""
 
-#: vms-misc.c:924
+#: vms-misc.c:923
 msgid "_bfd_vms_output_counted called with too many bytes"
 msgstr ""
 
-#: vms-misc.c:1055
+#: vms-misc.c:1054
 #, c-format
 msgid "Symbol %s replaced by %s\n"
 msgstr ""
 
-#: vms-misc.c:1117
+#: vms-misc.c:1116
 #, c-format
 msgid "failed to enter %s"
 msgstr ""
@@ -2349,109 +2352,109 @@ msgstr ""
 msgid "%s: reloc %s:%d not in csect"
 msgstr ""
 
-#: xcofflink.c:2092
+#: xcofflink.c:2094
 #, c-format
 msgid "%s: XCOFF shared object when not producing XCOFF output"
 msgstr ""
 
-#: xcofflink.c:2113
+#: xcofflink.c:2115
 #, c-format
 msgid "%s: dynamic object with no .loader section"
 msgstr ""
 
-#: xcofflink.c:2758
+#: xcofflink.c:2760
 #, c-format
 msgid "%s: no such symbol"
 msgstr ""
 
-#: xcofflink.c:2891
+#: xcofflink.c:2893
 msgid "error: undefined symbol __rtinit"
 msgstr ""
 
-#: xcofflink.c:3453
+#: xcofflink.c:3455
 #, c-format
 msgid "warning: attempt to export undefined symbol `%s'"
 msgstr ""
 
-#: xcofflink.c:4447
+#: xcofflink.c:4449
 #, c-format
 msgid "TOC overflow: 0x%lx > 0x10000; try -mminimal-toc when compiling"
 msgstr ""
 
-#: xcofflink.c:5287 xcofflink.c:5756 xcofflink.c:5818 xcofflink.c:6119
+#: xcofflink.c:5289 xcofflink.c:5758 xcofflink.c:5820 xcofflink.c:6124
 #, c-format
 msgid "%s: loader reloc in unrecognized section `%s'"
 msgstr ""
 
-#: xcofflink.c:5309 xcofflink.c:6130
+#: xcofflink.c:5311 xcofflink.c:6135
 #, c-format
 msgid "%s: `%s' in loader reloc but not loader sym"
 msgstr ""
 
-#: xcofflink.c:5324
+#: xcofflink.c:5326
 #, c-format
 msgid "%s: loader reloc in read-only section %s"
 msgstr ""
 
-#: elf32-ia64.c:2222 elf64-ia64.c:2222
+#: elf32-ia64.c:2228 elf64-ia64.c:2228
 msgid "@pltoff reloc against local symbol"
 msgstr ""
 
-#: elf32-ia64.c:3562 elf64-ia64.c:3562
+#: elf32-ia64.c:3568 elf64-ia64.c:3568
 #, c-format
 msgid "%s: short data segment overflowed (0x%lx >= 0x400000)"
 msgstr ""
 
-#: elf32-ia64.c:3573 elf64-ia64.c:3573
+#: elf32-ia64.c:3579 elf64-ia64.c:3579
 #, c-format
 msgid "%s: __gp does not cover short data segment"
 msgstr ""
 
-#: elf32-ia64.c:3858 elf64-ia64.c:3858
+#: elf32-ia64.c:3864 elf64-ia64.c:3864
 #, c-format
 msgid "%s: linking non-pic code in a shared library"
 msgstr ""
 
-#: elf32-ia64.c:3891 elf64-ia64.c:3891
+#: elf32-ia64.c:3897 elf64-ia64.c:3897
 #, c-format
 msgid "%s: @gprel relocation against dynamic symbol %s"
 msgstr ""
 
-#: elf32-ia64.c:4030 elf64-ia64.c:4030
+#: elf32-ia64.c:4036 elf64-ia64.c:4036
 #, c-format
 msgid "%s: dynamic relocation against speculation fixup"
 msgstr ""
 
-#: elf32-ia64.c:4038 elf64-ia64.c:4038
+#: elf32-ia64.c:4044 elf64-ia64.c:4044
 #, c-format
 msgid "%s: speculation fixup against undefined weak symbol"
 msgstr ""
 
-#: elf32-ia64.c:4271 elf64-ia64.c:4271
+#: elf32-ia64.c:4277 elf64-ia64.c:4277
 msgid "unsupported reloc"
 msgstr ""
 
-#: elf32-ia64.c:4551 elf64-ia64.c:4551
+#: elf32-ia64.c:4557 elf64-ia64.c:4557
 #, c-format
 msgid "%s: linking trap-on-NULL-dereference with non-trapping files"
 msgstr ""
 
-#: elf32-ia64.c:4560 elf64-ia64.c:4560
+#: elf32-ia64.c:4566 elf64-ia64.c:4566
 #, c-format
 msgid "%s: linking big-endian files with little-endian files"
 msgstr ""
 
-#: elf32-ia64.c:4569 elf64-ia64.c:4569
+#: elf32-ia64.c:4575 elf64-ia64.c:4575
 #, c-format
 msgid "%s: linking 64-bit files with 32-bit files"
 msgstr ""
 
-#: elf32-ia64.c:4578 elf64-ia64.c:4578
+#: elf32-ia64.c:4584 elf64-ia64.c:4584
 #, c-format
 msgid "%s: linking constant-gp files with non-constant-gp files"
 msgstr ""
 
-#: elf32-ia64.c:4588 elf64-ia64.c:4588
+#: elf32-ia64.c:4594 elf64-ia64.c:4594
 #, c-format
 msgid "%s: linking auto-pic files with non-auto-pic files"
 msgstr ""
diff --git a/contrib/binutils/bfd/reloc.c b/contrib/binutils/bfd/reloc.c
index 59f7819..01ff516 100644
--- a/contrib/binutils/bfd/reloc.c
+++ b/contrib/binutils/bfd/reloc.c
@@ -3574,7 +3574,7 @@ const char *
 bfd_get_reloc_code_name (code)
      bfd_reloc_code_real_type code;
 {
-  if (code > BFD_RELOC_UNUSED)
+  if ((int) code > (int) BFD_RELOC_UNUSED)
     return 0;
   return bfd_reloc_code_real_names[(int)code];
 }
@@ -3702,7 +3702,7 @@ bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
 
   /* We're not relaxing the section, so just copy the size info.  */
   input_section->_cooked_size = input_section->_raw_size;
-  input_section->reloc_done = true;
+  input_section->reloc_done = (unsigned int) true;
 
   reloc_count = bfd_canonicalize_reloc (input_bfd,
 					input_section,
diff --git a/contrib/binutils/bfd/section.c b/contrib/binutils/bfd/section.c
index 51b21c7..b5871e9 100644
--- a/contrib/binutils/bfd/section.c
+++ b/contrib/binutils/bfd/section.c
@@ -643,7 +643,8 @@ bfd_section_hash_newfunc (entry, table, string)
      subclass.  */
   if (entry == NULL)
     {
-      entry = bfd_hash_allocate (table, sizeof (struct section_hash_entry));
+      entry = (struct bfd_hash_entry *)
+	bfd_hash_allocate (table, sizeof (struct section_hash_entry));
       if (entry == NULL)
 	return entry;
     }
@@ -1186,7 +1187,7 @@ bfd_set_section_contents (abfd, section, location, offset, count)
 
   /* Record a copy of the data in memory if desired.  */
   if (section->contents
-      && location != section->contents + offset)
+      && location != (PTR) (section->contents + offset))
     memcpy (section->contents + offset, location, (size_t) count);
 
   if (BFD_SEND (abfd, _bfd_set_section_contents,
diff --git a/contrib/binutils/bfd/srec.c b/contrib/binutils/bfd/srec.c
index 129b2ba..6c29fa1 100644
--- a/contrib/binutils/bfd/srec.c
+++ b/contrib/binutils/bfd/srec.c
@@ -181,7 +181,7 @@ unsigned int Chunk = DEFAULT_CHUNK;
 /* The type of srec output (free or forced to S3).
    This variable can be modified by objcopy's --srec-forceS3
    parameter.  */
-boolean S3Forced = 0;
+boolean S3Forced = false;
 
 /* When writing an S-record file, the S-records can not be output as
    they are seen.  This structure is used to hold them in memory.  */
@@ -1203,7 +1203,7 @@ srec_get_symtab (abfd, alocation)
 
       csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
       if (csymbols == NULL && symcount != 0)
-	return false;
+	return (long) false;
       abfd->tdata.srec_data->csymbols = csymbols;
 
       for (s = abfd->tdata.srec_data->symbols, c = csymbols;
diff --git a/contrib/binutils/bfd/stabs.c b/contrib/binutils/bfd/stabs.c
index e225d9c..0cb3741 100644
--- a/contrib/binutils/bfd/stabs.c
+++ b/contrib/binutils/bfd/stabs.c
@@ -331,7 +331,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo)
 	 symbol, ignoring nesting, adding up all the characters in the
 	 symbol names, not including the file numbers in types (the
 	 first number after an open parenthesis).  */
-      if (type == N_BINCL)
+      if (type == (int) N_BINCL)
 	{
 	  bfd_vma val;
 	  int nest;
@@ -351,13 +351,13 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo)
 	      incl_type = incl_sym[TYPEOFF];
 	      if (incl_type == 0)
 		break;
-	      else if (incl_type == N_EINCL)
+	      else if (incl_type == (int) N_EINCL)
 		{
 		  if (nest == 0)
 		    break;
 		  --nest;
 		}
-	      else if (incl_type == N_BINCL)
+	      else if (incl_type == (int) N_BINCL)
 		++nest;
 	      else if (nest == 0)
 		{
@@ -400,7 +400,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo)
 	    goto error_return;
 	  ne->offset = sym - stabbuf;
 	  ne->val = val;
-	  ne->type = N_BINCL;
+	  ne->type = (int) N_BINCL;
 	  ne->next = secinfo->excls;
 	  secinfo->excls = ne;
 
@@ -422,7 +422,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo)
 
 	      /* We have seen this header file before.  Tell the final
 		 pass to change the type to N_EXCL.  */
-	      ne->type = N_EXCL;
+	      ne->type = (int) N_EXCL;
 
 	      /* Mark the skipped symbols.  */
 
@@ -435,7 +435,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo)
 
 		  incl_type = incl_sym[TYPEOFF];
 
-		  if (incl_type == N_EINCL)
+		  if (incl_type == (int) N_EINCL)
 		    {
 		      if (nest == 0)
 			{
@@ -445,7 +445,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo)
 			}
 		      --nest;
 		    }
-		  else if (incl_type == N_BINCL)
+		  else if (incl_type == (int) N_BINCL)
 		    ++nest;
 		  else if (nest == 0)
 		    {
@@ -597,7 +597,7 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo,
 
       type = sym[TYPEOFF];
 
-      if (type == N_FUN)
+      if (type == (int) N_FUN)
 	{
 	  int strx = bfd_get_32 (abfd, sym + STRDXOFF);
 
@@ -624,7 +624,7 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo,
       else if (deleting == -1)
 	{
 	  /* Outside of a function.  Check for deleted variables.  */
-	  if (type == N_STSYM || type == N_LCSYM)
+	  if (type == (int) N_STSYM || type == (int) N_LCSYM)
 	    if ((*reloc_symbol_deleted_p) (sym + VALOFF - stabbuf, cookie))
 	      {
 		*pstridx = -1;
@@ -674,7 +674,7 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo,
       BFD_ASSERT (offset != 0);
     }
 
-  return (skip > 0);
+  return (boolean) (skip > 0);
 
  error_return:
   if (stabbuf != NULL)
diff --git a/contrib/binutils/bfd/syms.c b/contrib/binutils/bfd/syms.c
index 8a8abf4..da71d80 100644
--- a/contrib/binutils/bfd/syms.c
+++ b/contrib/binutils/bfd/syms.c
@@ -713,7 +713,7 @@ boolean
 bfd_is_undefined_symclass (symclass)
      int symclass;
 {
-  return symclass == 'U' || symclass == 'w' || symclass == 'v';
+  return (boolean) (symclass == 'U' || symclass == 'w' || symclass == 'v');
 }
 
 /*
@@ -1069,7 +1069,7 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
       saw_fun = 1;
       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
 	{
-	  if (stab[TYPEOFF] == N_SO)
+	  if (stab[TYPEOFF] == (bfd_byte) N_SO)
 	    {
 	      /* N_SO with null name indicates EOF */
 	      if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
@@ -1083,12 +1083,12 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 
 	      /* two N_SO's in a row is a filename and directory. Skip */
 	      if (stab + STABSIZE < info->stabs + stabsize
-		  && *(stab + STABSIZE + TYPEOFF) == N_SO)
+		  && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
 		{
 		  stab += STABSIZE;
 		}
 	    }
-	  else if (stab[TYPEOFF] == N_FUN)
+	  else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
 	    {
 	      saw_fun = 1;
 	      ++info->indextablesize;
@@ -1157,7 +1157,7 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 		{
 		  last_stab = stab;
 		  if (stab + STABSIZE >= info->stabs + stabsize
-		      || *(stab + STABSIZE + TYPEOFF) != N_SO)
+		      || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
 		    {
 		      directory_name = NULL;
 		    }
diff --git a/contrib/binutils/bfd/targets.c b/contrib/binutils/bfd/targets.c
index d41edf6..2d0ec04 100644
--- a/contrib/binutils/bfd/targets.c
+++ b/contrib/binutils/bfd/targets.c
@@ -521,7 +521,6 @@ extern const bfd_target bfd_elf32_hppa_vec;
 extern const bfd_target bfd_elf32_i370_vec;
 extern const bfd_target bfd_elf32_i386_freebsd_vec;
 extern const bfd_target bfd_elf32_i386_vec;
-extern const bfd_target bfd_elf32_i386qnx_vec;
 extern const bfd_target bfd_elf32_i860_little_vec;
 extern const bfd_target bfd_elf32_i860_vec;
 extern const bfd_target bfd_elf32_i960_vec;
@@ -785,7 +784,6 @@ static const bfd_target * const _bfd_target_vector[] = {
 	&bfd_elf32_i370_vec,
 	&bfd_elf32_i386_freebsd_vec,
 	&bfd_elf32_i386_vec,
-	&bfd_elf32_i386qnx_vec,
 	&bfd_elf32_i860_little_vec,
 	&bfd_elf32_i860_vec,
 	&bfd_elf32_i960_vec,
@@ -1249,7 +1247,9 @@ bfd_target_list ()
     return NULL;
 
   for (target = &bfd_target_vector[0]; *target != NULL; target++)
-    *(name_ptr++) = (*target)->name;
+    if (target == &bfd_target_vector[0]
+	|| *target != bfd_target_vector[0])
+      *name_ptr++ = (*target)->name;
 
   return name_list;
 }
diff --git a/contrib/binutils/bfd/version.h b/contrib/binutils/bfd/version.h
index a440678..6dac811 100644
--- a/contrib/binutils/bfd/version.h
+++ b/contrib/binutils/bfd/version.h
@@ -1 +1 @@
-#define BFD_VERSION_DATE 20021011
+#define BFD_VERSION_DATE 20021127
diff --git a/contrib/binutils/bfd/xcofflink.c b/contrib/binutils/bfd/xcofflink.c
index a869d7d..e4e4755 100644
--- a/contrib/binutils/bfd/xcofflink.c
+++ b/contrib/binutils/bfd/xcofflink.c
@@ -1986,6 +1986,7 @@ xcoff_link_add_symbols (abfd, info)
 		      && h->descriptor == NULL)
 		    {
 		      struct xcoff_link_hash_entry *hds;
+		      struct bfd_link_hash_entry *bh;
 
 		      hds = xcoff_link_hash_lookup (xcoff_hash_table (info),
 						    h->root.root.string + 1,
@@ -1994,13 +1995,14 @@ xcoff_link_add_symbols (abfd, info)
 			goto error_return;
 		      if (hds->root.type == bfd_link_hash_new)
 			{
+			  bh = &hds->root;
 			  if (! (_bfd_generic_link_add_one_symbol
 				 (info, abfd, hds->root.root.string,
 				  (flagword) 0, bfd_und_section_ptr,
 				  (bfd_vma) 0, (const char *) NULL, false,
-				  true,
-				  (struct bfd_link_hash_entry **) &hds)))
+				  true, &bh)))
 			    goto error_return;
+			  hds = (struct xcoff_link_hash_entry *) bh;
 			}
 		      hds->flags |= XCOFF_DESCRIPTOR;
 		      BFD_ASSERT ((hds->flags & XCOFF_CALLED) == 0