Add s390 support

17 files changed, 4676 insertions, 42 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 082c643..9669fd4 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,17 @@
+2001-02-09  Martin Schwidefsky  <schwidefsky@de.ibm.com>
+
+	* Makefile.am: Add linux target for S/390.
+	* archures.c: Likewise.
+	* bfd-in2.h: Likewise.
+	* config.bfd: Likewise.
+	* configure.in: Likewise.
+	* elf.c: Likewise.
+	* libbfd.h: Likewise.
+	* targets.c: Likewise.
+	* cpu-s390.c: New file.
+	* elf32-s390.c: New file.
+	* elf64-s390.c: New file.
+
 2001-02-09  Nick Clifton  <nickc@redhat.com>
 
 	* peigen.c (_bfd_pe_get_symbol_info): Suppress addition of
diff --git a/bfd/Makefile.am b/bfd/Makefile.am
index 9a60ee6..821fab1 100644
--- a/bfd/Makefile.am
+++ b/bfd/Makefile.am
@@ -72,6 +72,7 @@ ALL_MACHINES = \
 	cpu-pj.lo \
 	cpu-powerpc.lo \
 	cpu-rs6000.lo \
+	cpu-s390.lo \
 	cpu-sh.lo \
 	cpu-sparc.lo \
 	cpu-tic30.lo \
@@ -114,6 +115,7 @@ ALL_MACHINES_CFILES = \
 	cpu-pj.c \
 	cpu-powerpc.c \
 	cpu-rs6000.c \
+	cpu-s390.c \
 	cpu-sh.c \
 	cpu-sparc.c \
 	cpu-tic30.c \
@@ -199,6 +201,7 @@ BFD32_BACKENDS = \
 	elf32-mips.lo \
 	elf32-pj.lo \
 	elf32-ppc.lo \
+	elf32-s390.lo \
 	elf32-sh.lo \
 	elf32-sh-lin.lo \
 	elf32-sparc.lo \
@@ -336,6 +339,7 @@ BFD32_BACKENDS_CFILES = \
 	elf32-mips.c \
 	elf32-pj.c \
 	elf32-ppc.c \
+	elf32-s390.c \
 	elf32-sh.c \
 	elf32-sh-lin.c \
 	elf32-sparc.c \
@@ -417,6 +421,7 @@ BFD64_BACKENDS = \
 	elf64-ia64.lo \
 	elf64-gen.lo \
 	elf64-mips.lo \
+	elf64-s390.lo \
 	elf64-sparc.lo \
 	elf64.lo \
 	nlm32-alpha.lo \
@@ -433,6 +438,7 @@ BFD64_BACKENDS_CFILES = \
 	elf64-hppa.c \
 	elf64-gen.c \
 	elf64-mips.c \
+	elf64-s390.c \
 	elf64-sparc.c \
 	elf64.c \
 	nlm32-alpha.c \
@@ -767,6 +773,7 @@ cpu-ns32k.lo: cpu-ns32k.c $(INCDIR)/filenames.h ns32k.h
 cpu-pj.lo: cpu-pj.c $(INCDIR)/filenames.h
 cpu-powerpc.lo: cpu-powerpc.c $(INCDIR)/filenames.h
 cpu-rs6000.lo: cpu-rs6000.c $(INCDIR)/filenames.h
+cpu-s390.lo: cpu-s390.c $(INCDIR)/filenames.h
 cpu-sh.lo: cpu-sh.c $(INCDIR)/filenames.h
 cpu-sparc.lo: cpu-sparc.c $(INCDIR)/filenames.h
 cpu-tic30.lo: cpu-tic30.c $(INCDIR)/filenames.h
@@ -1025,6 +1032,11 @@ elf32-ppc.lo: elf32-ppc.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/elf/ppc.h $(INCDIR)/elf/reloc-macros.h \
   elf32-target.h
+elf32-s390.lo: elf32-s390.c $(INCDIR)/filenames.h \
+  $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
+  $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/elf/s390.h \
+  $(INCDIR)/elf/reloc-macros.h $(INCDIR)/opcode/s390.h \
+  elf32-target.h
 elf32-sh.lo: elf32-sh.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/elf/sh.h $(INCDIR)/elf/reloc-macros.h \
@@ -1269,6 +1281,11 @@ elf64-mips.lo: elf64-mips.c $(INCDIR)/filenames.h $(INCDIR)/aout/ar.h \
   $(INCDIR)/elf/reloc-macros.h $(INCDIR)/coff/sym.h $(INCDIR)/coff/symconst.h \
   $(INCDIR)/coff/internal.h $(INCDIR)/coff/ecoff.h $(INCDIR)/coff/alpha.h \
   ecoffswap.h elf64-target.h
+elf64-s390.lo: elf64-s390.c $(INCDIR)/filenames.h \
+  elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
+  $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(INCDIR)/opcode/s390.h \
+  $(INCDIR)/elf/s390.h $(INCDIR)/elf/reloc-macros.h \
+  elf64-target.h
 elf64-sparc.lo: elf64-sparc.c $(INCDIR)/filenames.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(INCDIR)/opcode/sparc.h \
diff --git a/bfd/Makefile.in b/bfd/Makefile.in
index 0b5f886..808fb72 100644
--- a/bfd/Makefile.in
+++ b/bfd/Makefile.in
@@ -193,6 +193,7 @@ ALL_MACHINES = \
 	cpu-pj.lo \
 	cpu-powerpc.lo \
 	cpu-rs6000.lo \
+	cpu-s390.lo \
 	cpu-sh.lo \
 	cpu-sparc.lo \
 	cpu-tic30.lo \
@@ -236,6 +237,7 @@ ALL_MACHINES_CFILES = \
 	cpu-pj.c \
 	cpu-powerpc.c \
 	cpu-rs6000.c \
+	cpu-s390.c \
 	cpu-sh.c \
 	cpu-sparc.c \
 	cpu-tic30.c \
@@ -322,6 +324,7 @@ BFD32_BACKENDS = \
 	elf32-mips.lo \
 	elf32-pj.lo \
 	elf32-ppc.lo \
+	elf32-s390.lo \
 	elf32-sh.lo \
 	elf32-sh-lin.lo \
 	elf32-sparc.lo \
@@ -460,6 +463,7 @@ BFD32_BACKENDS_CFILES = \
 	elf32-mips.c \
 	elf32-pj.c \
 	elf32-ppc.c \
+	elf32-s390.c \
 	elf32-sh.c \
 	elf32-sh-lin.c \
 	elf32-sparc.c \
@@ -542,6 +546,7 @@ BFD64_BACKENDS = \
 	elf64-ia64.lo \
 	elf64-gen.lo \
 	elf64-mips.lo \
+	elf64-s390.lo \
 	elf64-sparc.lo \
 	elf64.lo \
 	nlm32-alpha.lo \
@@ -559,6 +564,7 @@ BFD64_BACKENDS_CFILES = \
 	elf64-hppa.c \
 	elf64-gen.c \
 	elf64-mips.c \
+	elf64-s390.c \
 	elf64-sparc.c \
 	elf64.c \
 	nlm32-alpha.c \
@@ -1306,6 +1312,7 @@ cpu-ns32k.lo: cpu-ns32k.c $(INCDIR)/filenames.h ns32k.h
 cpu-pj.lo: cpu-pj.c $(INCDIR)/filenames.h
 cpu-powerpc.lo: cpu-powerpc.c $(INCDIR)/filenames.h
 cpu-rs6000.lo: cpu-rs6000.c $(INCDIR)/filenames.h
+cpu-s390.lo: cpu-s390.c $(INCDIR)/filenames.h
 cpu-sh.lo: cpu-sh.c $(INCDIR)/filenames.h
 cpu-sparc.lo: cpu-sparc.c $(INCDIR)/filenames.h
 cpu-tic30.lo: cpu-tic30.c $(INCDIR)/filenames.h
@@ -1564,6 +1571,11 @@ elf32-ppc.lo: elf32-ppc.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/elf/ppc.h $(INCDIR)/elf/reloc-macros.h \
   elf32-target.h
+elf32-s390.lo: elf32-s390.c $(INCDIR)/filenames.h \
+  $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
+  $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/elf/s390.h \
+  $(INCDIR)/elf/reloc-macros.h $(INCDIR)/opcode/s390.h \
+  elf32-target.h
 elf32-sh.lo: elf32-sh.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/elf/sh.h $(INCDIR)/elf/reloc-macros.h \
@@ -1808,6 +1820,11 @@ elf64-mips.lo: elf64-mips.c $(INCDIR)/filenames.h $(INCDIR)/aout/ar.h \
   $(INCDIR)/elf/reloc-macros.h $(INCDIR)/coff/sym.h $(INCDIR)/coff/symconst.h \
   $(INCDIR)/coff/internal.h $(INCDIR)/coff/ecoff.h $(INCDIR)/coff/alpha.h \
   ecoffswap.h elf64-target.h
+elf64-s390.lo: elf64-s390.c $(INCDIR)/filenames.h \
+  elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
+  $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(INCDIR)/opcode/s390.h \
+  $(INCDIR)/elf/s390.h $(INCDIR)/elf/reloc-macros.h \
+  elf64-target.h
 elf64-sparc.lo: elf64-sparc.c $(INCDIR)/filenames.h \
   elf-bfd.h $(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h \
   $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h $(INCDIR)/opcode/sparc.h \
diff --git a/bfd/archures.c b/bfd/archures.c
index 84b7744..b15de52 100644
--- a/bfd/archures.c
+++ b/bfd/archures.c
@@ -248,6 +248,9 @@ DESCRIPTION
 .#define bfd_mach_avr4		4
 .#define bfd_mach_avr5		5
 .  bfd_arch_cris,      {* Axis CRIS *}
+.  bfd_arch_s390,      {* IBM s390 *}
+.#define bfd_mach_s390_esa      0
+.#define bfd_mach_s390_esame    1
 .  bfd_arch_last
 .  };
 */
@@ -323,6 +326,7 @@ extern const bfd_arch_info_type bfd_fr30_arch;
 extern const bfd_arch_info_type bfd_mcore_arch;
 extern const bfd_arch_info_type bfd_avr_arch;
 extern const bfd_arch_info_type bfd_ia64_arch;
+extern const bfd_arch_info_type bfd_s390_arch;
 
 static const bfd_arch_info_type * const bfd_archures_list[] = {
 #ifdef SELECT_ARCHITECTURES
@@ -367,6 +371,7 @@ static const bfd_arch_info_type * const bfd_archures_list[] = {
   &bfd_mcore_arch,
   &bfd_avr_arch,
   &bfd_ia64_arch,
+  &bfd_s390_arch,
 #endif
   0
 };
diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index b8e864b..db4576d 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -1517,6 +1517,9 @@ enum bfd_architecture
 #define bfd_mach_avr4          4
 #define bfd_mach_avr5          5
   bfd_arch_cris,      /* Axis CRIS */
+  bfd_arch_s390,      /* IBM s390 */
+#define bfd_mach_s390_esa      0
+#define bfd_mach_s390_esame    1
   bfd_arch_last
   };
 
@@ -2515,6 +2518,57 @@ value of SUBI insn. */
 into 22 bits. */
   BFD_RELOC_AVR_CALL,
 
+/* Direct 12 bit. */
+  BFD_RELOC_390_12,
+
+/* 12 bit GOT offset. */
+  BFD_RELOC_390_GOT12,
+
+/* 32 bit PC relative PLT address. */
+  BFD_RELOC_390_PLT32,
+
+/* Copy symbol at runtime. */
+  BFD_RELOC_390_COPY,
+
+/* Create GOT entry. */
+  BFD_RELOC_390_GLOB_DAT,
+
+/* Create PLT entry. */
+  BFD_RELOC_390_JMP_SLOT,
+
+/* Adjust by program base. */
+  BFD_RELOC_390_RELATIVE,
+
+/* 32 bit PC relative offset to GOT. */
+  BFD_RELOC_390_GOTPC,
+
+/* 16 bit GOT offset. */
+  BFD_RELOC_390_GOT16,
+
+/* PC relative 16 bit shifted by 1. */
+  BFD_RELOC_390_PC16DBL,
+
+/* 16 bit PC rel. PLT shifted by 1. */
+  BFD_RELOC_390_PLT16DBL,
+
+/* PC relative 32 bit shifted by 1. */
+  BFD_RELOC_390_PC32DBL,
+
+/* 32 bit PC rel. PLT shifted by 1. */
+  BFD_RELOC_390_PLT32DBL,
+
+/* 32 bit PC rel. GOT shifted by 1. */
+  BFD_RELOC_390_GOTPCDBL,
+
+/* 64 bit GOT offset. */
+  BFD_RELOC_390_GOT64,
+
+/* 64 bit PC relative PLT address. */
+  BFD_RELOC_390_PLT64,
+
+/* 32 bit rel. offset to GOT entry. */
+  BFD_RELOC_390_GOTENT,
+
 /* These two relocations are used by the linker to determine which of
 the entries in a C++ virtual function table are actually used.  When
 the --gc-sections option is given, the linker will zero out the entries
diff --git a/bfd/config.bfd b/bfd/config.bfd
index 580c82d..f45e839 100644
--- a/bfd/config.bfd
+++ b/bfd/config.bfd
@@ -46,6 +46,7 @@ m88*)	targ_archs=bfd_m88k_arch ;;
 mips*)	targ_archs=bfd_mips_arch ;;
 pj*)	targ_archs="bfd_pj_arch bfd_i386_arch";;
 powerpc*) targ_archs="bfd_rs6000_arch bfd_powerpc_arch" ;;
+s390*)  targ_archs=bfd_s390_arch ;;
 rs6000)	targ_archs="bfd_rs6000_arch bfd_powerpc_arch" ;;
 sparc*) targ_archs=bfd_sparc_arch ;;
 v850*)	targ_archs=bfd_v850_arch ;;
@@ -718,6 +719,15 @@ case "${targ}" in
     targ_selvecs="bfd_powerpcle_pei_vec bfd_powerpc_pei_vec bfd_powerpcle_pe_vec bfd_powerpc_pe_vec"
     ;;
 
+  s390-*-linux*)
+    targ_defvec=bfd_elf32_s390_vec
+    ;;
+#ifdef BFD64
+  s390x-*-linux*)
+    targ_defvec=bfd_elf64_s390_vec
+    ;;
+#endif
+
   sh-*-linux*)
     targ_defvec=bfd_elf32_shblin_vec
     targ_selvecs=bfd_elf32_shlin_vec
diff --git a/bfd/configure b/bfd/configure
index d65a378..35bb8a1 100755
--- a/bfd/configure
+++ b/bfd/configure
@@ -5982,6 +5982,7 @@ do
     bfd_elf32_pjl_vec)          tb="$tb elf32-pj.lo elf32.lo $elf";;
     bfd_elf32_powerpc_vec)	tb="$tb elf32-ppc.lo elf32.lo $elf" ;;
     bfd_elf32_powerpcle_vec)	tb="$tb elf32-ppc.lo elf32.lo $elf" ;;
+    bfd_elf32_s390_vec)		tb="$tb elf32-s390.lo elf32.lo $elf" ;;
     bfd_elf32_sh_vec)		tb="$tb elf32-sh.lo elf32.lo $elf coff-sh.lo" ;;
     bfd_elf32_shl_vec)		tb="$tb elf32-sh.lo elf32.lo $elf coff-sh.lo" ;;
     bfd_elf32_shlin_vec)	tb="$tb elf32-sh-lin.lo elf32.lo $elf coff-sh.lo cofflink.lo" ;;
@@ -5994,6 +5995,8 @@ do
 				target64=true ;;
     bfd_elf64_little_generic_vec) tb="$tb elf64-gen.lo elf64.lo $elf"
 				target64=true ;;
+    bfd_elf64_s390_vec)		tb="$tb elf64-s390.lo elf64.lo $elf" 
+				target64=true ;;
     bfd_elf64_sparc_vec)	tb="$tb elf64-sparc.lo elf64.lo $elf"
 				target64=true ;;
     cisco_core_big_vec)		tb="$tb cisco-core.lo" ;;
@@ -6179,17 +6182,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:6183: checking for $ac_hdr" >&5
+echo "configure:6186: 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 6188 "configure"
+#line 6191 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:6193: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:6196: \"$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*
@@ -6218,12 +6221,12 @@ done
 for ac_func in getpagesize
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6222: checking for $ac_func" >&5
+echo "configure:6225: 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 6227 "configure"
+#line 6230 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -6246,7 +6249,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:6250: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6253: \"$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
@@ -6271,7 +6274,7 @@ fi
 done
 
 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:6275: checking for working mmap" >&5
+echo "configure:6278: 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
@@ -6279,7 +6282,7 @@ else
   ac_cv_func_mmap_fixed_mapped=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 6283 "configure"
+#line 6286 "configure"
 #include "confdefs.h"
 
 /* Thanks to Mike Haertel and Jim Avera for this test.
@@ -6419,7 +6422,7 @@ main()
 }
 
 EOF
-if { (eval echo configure:6423: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:6426: \"$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
@@ -6444,12 +6447,12 @@ fi
 for ac_func in madvise mprotect
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6448: checking for $ac_func" >&5
+echo "configure:6451: 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 6453 "configure"
+#line 6456 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -6472,7 +6475,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:6476: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6479: \"$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/bfd/configure.in b/bfd/configure.in
index d643b97..a65cb91 100644
--- a/bfd/configure.in
+++ b/bfd/configure.in
@@ -531,6 +531,7 @@ do
     bfd_elf32_pjl_vec)          tb="$tb elf32-pj.lo elf32.lo $elf";;
     bfd_elf32_powerpc_vec)	tb="$tb elf32-ppc.lo elf32.lo $elf" ;;
     bfd_elf32_powerpcle_vec)	tb="$tb elf32-ppc.lo elf32.lo $elf" ;;
+    bfd_elf32_s390_vec)		tb="$tb elf32-s390.lo elf32.lo $elf" ;;
     bfd_elf32_sh_vec)		tb="$tb elf32-sh.lo elf32.lo $elf coff-sh.lo" ;;
     bfd_elf32_shl_vec)		tb="$tb elf32-sh.lo elf32.lo $elf coff-sh.lo" ;;
     bfd_elf32_shlin_vec)	tb="$tb elf32-sh-lin.lo elf32.lo $elf coff-sh.lo cofflink.lo" ;;
@@ -543,6 +544,8 @@ do
 				target64=true ;;
     bfd_elf64_little_generic_vec) tb="$tb elf64-gen.lo elf64.lo $elf"
 				target64=true ;;
+    bfd_elf64_s390_vec)		tb="$tb elf64-s390.lo elf64.lo $elf" 
+				target64=true ;;
     bfd_elf64_sparc_vec)	tb="$tb elf64-sparc.lo elf64.lo $elf"
 				target64=true ;;
     cisco_core_big_vec)		tb="$tb cisco-core.lo" ;;
diff --git a/bfd/cpu-s390.c b/bfd/cpu-s390.c
new file mode 100644
index 0000000..15eb9a5
--- /dev/null
+++ b/bfd/cpu-s390.c
@@ -0,0 +1,56 @@
+/* BFD support for the s390 processor.
+   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+   Contributed by Carl B. Pedersen and Martin Schwidefsky.
+
+   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"
+
+const bfd_arch_info_type bfd_s390_esame_arch =
+{
+    64,        /* bits in a word */
+    64,        /* bits in an address */
+    8, /* bits in a byte */
+    bfd_arch_s390,
+    bfd_mach_s390_esame,
+    "s390",
+    "s390:esame",
+    3, /* section alignment power */
+    true, /* the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    NULL
+};
+
+const bfd_arch_info_type bfd_s390_arch =
+{
+    32,	/* bits in a word */
+    32,	/* bits in an address */
+    8,	/* bits in a byte */
+    bfd_arch_s390,
+    bfd_mach_s390_esa,
+    "s390",
+    "s390:390",
+    3, /* section alignment power */
+    true, /* the default */
+    bfd_default_compatible,
+    bfd_default_scan,
+    &bfd_s390_esame_arch
+};
diff --git a/bfd/elf.c b/bfd/elf.c
index 5ae24ee..d5d0579 100644
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -3320,6 +3320,9 @@ prep_headers (abfd)
     case bfd_arch_m68hc12:
       i_ehdrp->e_machine = EM_68HC12;
       break;
+    case bfd_arch_s390:
+      i_ehdrp->e_machine = EM_S390;
+      break;
     case bfd_arch_m68k:
       i_ehdrp->e_machine = EM_68K;
       break;
diff --git a/bfd/elf32-s390.c b/bfd/elf32-s390.c
new file mode 100644
index 0000000..313a41a
--- /dev/null
+++ b/bfd/elf32-s390.c
@@ -0,0 +1,2179 @@
+/* IBM S/390-specific support for 32-bit ELF
+   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+   Contributed by Carl B. Pedersen and Martin Schwidefsky.
+
+   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"
+
+static reloc_howto_type *elf_s390_reloc_type_lookup
+  PARAMS ((bfd *, bfd_reloc_code_real_type));
+static void elf_s390_info_to_howto
+  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
+static boolean elf_s390_is_local_label_name PARAMS ((bfd *, const char *));
+static struct bfd_hash_entry *elf_s390_link_hash_newfunc
+  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
+static struct bfd_link_hash_table *elf_s390_link_hash_table_create
+  PARAMS ((bfd *));
+static boolean elf_s390_check_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection *,
+	   const Elf_Internal_Rela *));
+static boolean elf_s390_adjust_dynamic_symbol
+  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+static boolean elf_s390_size_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static boolean elf_s390_relocate_section
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+	   Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
+static boolean elf_s390_finish_dynamic_symbol
+  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
+	   Elf_Internal_Sym *));
+static boolean elf_s390_finish_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+
+#define USE_RELA 1		/* We want RELA relocations, not REL.  */
+
+#include "elf/s390.h"
+
+/* The relocation "howto" table.  */
+
+static reloc_howto_type elf_howto_table[] =
+{
+  HOWTO (R_390_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 */
+	 bfd_elf_generic_reloc, /* special_function */
+	 "R_390_NONE",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO(R_390_8,         0, 0,  8, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_8",       false, 0,0x000000ff, false),
+  HOWTO(R_390_12,        0, 1, 12, false, 0, complain_overflow_dont, bfd_elf_generic_reloc, "R_390_12",      false, 0,0x00000fff, false),
+  HOWTO(R_390_16,        0, 1, 16, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_16",      false, 0,0x0000ffff, false),
+  HOWTO(R_390_32,        0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_32",      false, 0,0xffffffff, false),
+  HOWTO(R_390_PC32,	 0, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC32",    false, 0,0xffffffff,  true),
+  HOWTO(R_390_GOT12,	 0, 1, 12, false, 0, complain_overflow_dont, bfd_elf_generic_reloc, "R_390_GOT12",   false, 0,0x00000fff, false),
+  HOWTO(R_390_GOT32,	 0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT32",   false, 0,0xffffffff, false),
+  HOWTO(R_390_PLT32,	 0, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT32",   false, 0,0xffffffff,  true),
+  HOWTO(R_390_COPY,      0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_COPY",    false, 0,0xffffffff, false),
+  HOWTO(R_390_GLOB_DAT,  0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GLOB_DAT",false, 0,0xffffffff, false),
+  HOWTO(R_390_JMP_SLOT,  0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_JMP_SLOT",false, 0,0xffffffff, false),
+  HOWTO(R_390_RELATIVE,  0, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_RELATIVE",false, 0,0xffffffff, false),
+  HOWTO(R_390_GOTOFF,    0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTOFF",  false, 0,0xffffffff, false),
+  HOWTO(R_390_GOTPC,     0, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTPC",   false, 0,0xffffffff,  true),
+  HOWTO(R_390_GOT16,     0, 1, 16, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT16",   false, 0,0x0000ffff, false),
+  HOWTO(R_390_PC16,      0, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC16",    false, 0,0x0000ffff,  true),
+  HOWTO(R_390_PC16DBL,   1, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC16DBL", false, 0,0x0000ffff,  true),
+  HOWTO(R_390_PLT16DBL,  1, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT16DBL", false, 0,0x0000ffff,  true),
+};
+
+/* GNU extension to record C++ vtable hierarchy.  */
+static reloc_howto_type elf32_s390_vtinherit_howto =
+  HOWTO (R_390_GNU_VTINHERIT, 0,2,0,false,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", false,0, 0, false);
+static reloc_howto_type elf32_s390_vtentry_howto =
+  HOWTO (R_390_GNU_VTENTRY, 0,2,0,false,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_390_GNU_VTENTRY", false,0,0, false); 
+
+static reloc_howto_type *
+elf_s390_reloc_type_lookup (abfd, code)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     bfd_reloc_code_real_type code;
+{
+  switch (code) {
+  case BFD_RELOC_NONE:
+    return &elf_howto_table[(int) R_390_NONE];
+  case BFD_RELOC_8:
+    return &elf_howto_table[(int) R_390_8];
+  case BFD_RELOC_390_12:
+    return &elf_howto_table[(int) R_390_12];
+  case BFD_RELOC_16:
+    return &elf_howto_table[(int) R_390_16];
+  case BFD_RELOC_32:
+    return &elf_howto_table[(int) R_390_32];
+  case BFD_RELOC_CTOR:
+    return &elf_howto_table[(int) R_390_32];
+  case BFD_RELOC_32_PCREL:
+    return &elf_howto_table[(int) R_390_PC32];
+  case BFD_RELOC_390_GOT12:
+    return &elf_howto_table[(int) R_390_GOT12];
+  case BFD_RELOC_32_GOT_PCREL:
+    return &elf_howto_table[(int) R_390_GOT32];
+  case BFD_RELOC_390_PLT32:
+    return &elf_howto_table[(int) R_390_PLT32];
+  case BFD_RELOC_390_COPY:
+    return &elf_howto_table[(int) R_390_COPY];
+  case BFD_RELOC_390_GLOB_DAT:
+    return &elf_howto_table[(int) R_390_GLOB_DAT];
+  case BFD_RELOC_390_JMP_SLOT:
+    return &elf_howto_table[(int) R_390_JMP_SLOT];
+  case BFD_RELOC_390_RELATIVE:
+    return &elf_howto_table[(int) R_390_RELATIVE];
+  case BFD_RELOC_32_GOTOFF:
+    return &elf_howto_table[(int) R_390_GOTOFF];
+  case BFD_RELOC_390_GOTPC:
+    return &elf_howto_table[(int) R_390_GOTPC];
+  case BFD_RELOC_390_GOT16:
+    return &elf_howto_table[(int) R_390_GOT16];
+  case BFD_RELOC_16_PCREL:
+    return &elf_howto_table[(int) R_390_PC16];
+  case BFD_RELOC_390_PC16DBL:
+    return &elf_howto_table[(int) R_390_PC16DBL];
+  case BFD_RELOC_390_PLT16DBL:
+    return &elf_howto_table[(int) R_390_PLT16DBL];
+  case BFD_RELOC_VTABLE_INHERIT:
+    return &elf32_s390_vtinherit_howto;
+  case BFD_RELOC_VTABLE_ENTRY:
+    return &elf32_s390_vtentry_howto;
+  default:
+    break;                                         
+  }
+  return 0;
+}
+
+/* We need to use ELF32_R_TYPE so we have our own copy of this function,
+   and elf32-s390.c has its own copy.  */
+
+static void
+elf_s390_info_to_howto (abfd, cache_ptr, dst)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     arelent *cache_ptr;
+     Elf_Internal_Rela *dst;
+{
+  switch (ELF32_R_TYPE(dst->r_info))
+    {
+    case R_390_GNU_VTINHERIT:
+      cache_ptr->howto = &elf32_s390_vtinherit_howto;
+      break;
+
+    case R_390_GNU_VTENTRY:
+      cache_ptr->howto = &elf32_s390_vtentry_howto;
+      break;
+
+    default:
+      BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_390_max);
+      cache_ptr->howto = &elf_howto_table[ELF32_R_TYPE(dst->r_info)];
+    }     
+}
+
+static boolean
+elf_s390_is_local_label_name (abfd, name)
+     bfd *abfd;
+     const char *name;
+{
+  if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
+    return true;
+
+  return _bfd_elf_is_local_label_name (abfd, name);
+}
+
+/* Functions for the 390 ELF linker.  */
+
+/* The name of the dynamic interpreter.  This is put in the .interp
+   section.  */
+
+#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
+
+/* The nop opcode we use.  */
+
+#define s390_NOP 0x07070707
+
+
+/* The size in bytes of the first entry in the procedure linkage table.  */
+#define PLT_FIRST_ENTRY_SIZE 32
+/* The size in bytes of an entry in the procedure linkage table.  */
+#define PLT_ENTRY_SIZE 32 
+
+#define GOT_ENTRY_SIZE 4
+
+/* The first three entries in a procedure linkage table are reserved,
+   and the initial contents are unimportant (we zero them out).
+   Subsequent entries look like this.  See the SVR4 ABI 386
+   supplement to see how this works.  */
+
+/* For the s390, simple addr offset can only be 0 - 4096.
+   To use the full 2 GB address space, several instructions
+   are needed to load an address in a register and execute
+   a branch( or just saving the address)
+
+   Furthermore, only r 0 and 1 are free to use!!!  */ 
+
+/* The first 3 words in the GOT are then reserved.
+   Word 0 is the address of the dynamic table.
+   Word 1 is a pointer to a structure describing the object
+   Word 2 is used to point to the loader entry address.
+
+   The code for position independand PLT entries looks like this:
+
+   r12 holds addr of the current GOT at entry to the PLT
+
+   The GOT holds the address in the PLT to be executed.
+   The loader then gets:
+   24(15) =  Pointer to the structure describing the object.
+   28(15) =  Offset in symbol table                                             
+
+   The loader  must  then find the module where the function is
+   and insert the address in the GOT.
+
+  Note: 390 can only address +- 64 K relative.
+        We check if offset > 65536, then make a relative branch -64xxx
+        back to a previous defined branch
+
+PLT1: BASR 1,0         # 2 bytes
+      L    1,22(1)     # 4 bytes  Load offset in GOT in r 1
+      L    1,(1,12)    # 4 bytes  Load address from GOT in r1
+      BCR  15,1        # 2 bytes  Jump to address
+RET1: BASR 1,0         # 2 bytes  Return from GOT 1st time
+      L    1,14(1)     # 4 bytes  Load offset in symol table in r1
+      BRC  15,-x       # 4 bytes  Jump to start of PLT
+      .word 0          # 2 bytes filler
+      .long ?          # 4 bytes  offset in GOT
+      .long ?          # 4 bytes  offset into symbol table
+
+  This was the general case. There are two additional, optimizes PLT
+  definitions. One for GOT offsets < 4096 and one for GOT offsets < 32768.
+  First the one for GOT offsets < 4096:
+
+PLT1: L    1,<offset>(12) # 4 bytes  Load address from GOT in R1
+      BCR  15,1           # 2 bytes  Jump to address
+      .word 0,0,0         # 6 bytes  filler
+RET1: BASR 1,0            # 2 bytes  Return from GOT 1st time
+      L    1,14(1)        # 4 bytes  Load offset in symbol table in r1
+      BRC  15,-x          # 4 bytes  Jump to start of PLT
+      .word 0,0,0         # 6 bytes  filler
+      .long ?             # 4 bytes  offset into symbol table
+
+  Second the one for GOT offsets < 32768:
+
+PLT1: LHI  1,<offset>     # 4 bytes  Load offset in GOT to r1
+      L    1,(1,12)       # 4 bytes  Load address from GOT to r1
+      BCR  15,1           # 2 bytes  Jump to address
+      .word 0             # 2 bytes  filler
+RET1: BASR 1,0            # 2 bytes  Return from GOT 1st time
+      L    1,14(1)        # 4 bytes  Load offset in symbol table in r1
+      BRC  15,-x          # 4 bytes  Jump to start of PLT
+      .word 0,0,0         # 6 bytes  filler
+      .long ?             # 4 bytes  offset into symbol table
+
+Total = 32 bytes per PLT entry
+
+   The code for static build PLT entries looks like this:
+
+PLT1: BASR 1,0         # 2 bytes
+      L    1,22(1)     # 4 bytes  Load address of GOT entry
+      L    1,0(0,1)    # 4 bytes  Load address from GOT in r1
+      BCR  15,1        # 2 bytes  Jump to address
+RET1: BASR 1,0         # 2 bytes  Return from GOT 1st time
+      L    1,14(1)     # 4 bytes  Load offset in symbol table in r1
+      BRC  15,-x       # 4 bytes  Jump to start of PLT
+      .word 0          # 2 bytes  filler
+      .long ?          # 4 bytes  address of GOT entry
+      .long ?          # 4 bytes  offset into symbol table  */
+
+#define PLT_PIC_ENTRY_WORD0 0x0d105810
+#define PLT_PIC_ENTRY_WORD1 0x10165811
+#define PLT_PIC_ENTRY_WORD2 0xc00007f1
+#define PLT_PIC_ENTRY_WORD3 0x0d105810
+#define PLT_PIC_ENTRY_WORD4 0x100ea7f4
+
+#define PLT_PIC12_ENTRY_WORD0 0x5810c000
+#define PLT_PIC12_ENTRY_WORD1 0x07f10000
+#define PLT_PIC12_ENTRY_WORD2 0x00000000
+#define PLT_PIC12_ENTRY_WORD3 0x0d105810
+#define PLT_PIC12_ENTRY_WORD4 0x100ea7f4
+
+#define PLT_PIC16_ENTRY_WORD0 0xa7180000
+#define PLT_PIC16_ENTRY_WORD1 0x5811c000
+#define PLT_PIC16_ENTRY_WORD2 0x07f10000
+#define PLT_PIC16_ENTRY_WORD3 0x0d105810
+#define PLT_PIC16_ENTRY_WORD4 0x100ea7f4
+
+#define PLT_ENTRY_WORD0     0x0d105810
+#define PLT_ENTRY_WORD1     0x10165810
+#define PLT_ENTRY_WORD2     0x100007f1
+#define PLT_ENTRY_WORD3     0x0d105810
+#define PLT_ENTRY_WORD4     0x100ea7f4
+
+/* The first PLT entry pushes the offset into the symbol table
+   from R1 onto the stack at 8(15) and the loader object info
+   at 12(15), loads the loader address in R1 and jumps to it.  */
+
+/* The first entry in the PLT for PIC code:
+
+PLT0:
+   ST   1,28(15)  # R1 has offset into symbol table
+   L    1,4(12)   # Get loader ino(object struct address)
+   ST   1,24(15)  # Store address 
+   L    1,8(12)   # Entry address of loader in R1
+   BR   1         # Jump to loader
+
+   The first entry in the PLT for static code:
+
+PLT0:
+   ST   1,28(15)      # R1 has offset into symbol table
+   BASR 1,0
+   L    1,18(0,1)     # Get address of GOT
+   MVC  24(4,15),4(1) # Move loader ino to stack
+   L    1,8(1)        # Get address of loader
+   BR   1             # Jump to loader
+   .word 0            # filler
+   .long got          # address of GOT  */
+
+#define PLT_PIC_FIRST_ENTRY_WORD0 0x5010f01c
+#define PLT_PIC_FIRST_ENTRY_WORD1 0x5810c004
+#define PLT_PIC_FIRST_ENTRY_WORD2 0x5010f018
+#define PLT_PIC_FIRST_ENTRY_WORD3 0x5810c008
+#define PLT_PIC_FIRST_ENTRY_WORD4 0x07f10000
+
+#define PLT_FIRST_ENTRY_WORD0     0x5010f01c
+#define PLT_FIRST_ENTRY_WORD1     0x0d105810
+#define PLT_FIRST_ENTRY_WORD2     0x1012D203
+#define PLT_FIRST_ENTRY_WORD3     0xf0181004
+#define PLT_FIRST_ENTRY_WORD4     0x58101008
+#define PLT_FIRST_ENTRY_WORD5     0x07f10000
+
+/* The s390 linker needs to keep track of the number of relocs that it
+   decides to copy in check_relocs for each symbol.  This is so that
+   it can discard PC relative relocs if it doesn't need them when
+   linking with -Bsymbolic.  We store the information in a field
+   extending the regular ELF linker hash table.  */
+
+/* This structure keeps track of the number of PC relative relocs we
+   have copied for a given symbol.  */
+
+struct elf_s390_pcrel_relocs_copied
+{
+  /* Next section.  */
+  struct elf_s390_pcrel_relocs_copied *next;
+  /* A section in dynobj.  */
+  asection *section;
+  /* Number of relocs copied in this section.  */
+  bfd_size_type count;
+};
+
+/* s390 ELF linker hash entry.  */
+
+struct elf_s390_link_hash_entry
+{
+  struct elf_link_hash_entry root;
+
+  /* Number of PC relative relocs copied for this symbol.  */
+  struct elf_s390_pcrel_relocs_copied *pcrel_relocs_copied;
+};
+
+/* s390 ELF linker hash table.  */
+
+struct elf_s390_link_hash_table
+{
+  struct elf_link_hash_table root;
+};
+
+/* Declare this now that the above structures are defined.  */
+
+static boolean elf_s390_discard_copies
+  PARAMS ((struct elf_s390_link_hash_entry *, PTR));
+
+/* Traverse an s390 ELF linker hash table.  */
+
+#define elf_s390_link_hash_traverse(table, func, info)			\
+  (elf_link_hash_traverse						\
+   (&(table)->root,							\
+    (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),	\
+    (info)))
+
+/* Get the s390 ELF linker hash table from a link_info structure.  */
+
+#define elf_s390_hash_table(p) \
+  ((struct elf_s390_link_hash_table *) ((p)->hash))
+
+/* Create an entry in an s390 ELF linker hash table.  */
+
+static struct bfd_hash_entry *
+elf_s390_link_hash_newfunc (entry, table, string)
+     struct bfd_hash_entry *entry;
+     struct bfd_hash_table *table;
+     const char *string;
+{
+  struct elf_s390_link_hash_entry *ret =
+    (struct elf_s390_link_hash_entry *) entry;
+
+  /* Allocate the structure if it has not already been allocated by a
+     subclass.  */
+  if (ret == (struct elf_s390_link_hash_entry *) NULL)
+    ret = ((struct elf_s390_link_hash_entry *)
+	   bfd_hash_allocate (table,
+			      sizeof (struct elf_s390_link_hash_entry)));
+  if (ret == (struct elf_s390_link_hash_entry *) NULL)
+    return (struct bfd_hash_entry *) ret;
+
+  /* Call the allocation method of the superclass.  */
+  ret = ((struct elf_s390_link_hash_entry *)
+	 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
+				     table, string));
+  if (ret != (struct elf_s390_link_hash_entry *) NULL)
+    {
+      ret->pcrel_relocs_copied = NULL;
+    }
+
+  return (struct bfd_hash_entry *) ret;
+}
+
+/* Create an s390 ELF linker hash table.  */
+
+static struct bfd_link_hash_table *
+elf_s390_link_hash_table_create (abfd)
+     bfd *abfd;
+{
+  struct elf_s390_link_hash_table *ret;
+
+  ret = ((struct elf_s390_link_hash_table *)
+	 bfd_alloc (abfd, sizeof (struct elf_s390_link_hash_table)));
+  if (ret == (struct elf_s390_link_hash_table *) NULL)
+    return NULL;
+
+  if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
+				       elf_s390_link_hash_newfunc))
+    {
+      bfd_release (abfd, ret);
+      return NULL;
+    }
+
+  return &ret->root.root;
+}
+
+
+/* Look through the relocs for a section during the first phase, and
+   allocate space in the global offset table or procedure linkage
+   table.  */
+
+static boolean
+elf_s390_check_relocs (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+  bfd *dynobj;
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  bfd_signed_vma *local_got_refcounts;
+  const Elf_Internal_Rela *rel;
+  const Elf_Internal_Rela *rel_end;
+  asection *sgot;
+  asection *srelgot;
+  asection *sreloc;
+
+  if (info->relocateable)
+    return true;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_refcounts = elf_local_got_offsets (abfd);
+
+  sgot = NULL;
+  srelgot = NULL;
+  sreloc = NULL;
+
+  rel_end = relocs + sec->reloc_count;
+  for (rel = relocs; rel < rel_end; rel++)
+    {
+      unsigned long r_symndx;
+      struct elf_link_hash_entry *h;
+
+      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 (dynobj == NULL)
+	{
+	  switch (ELF32_R_TYPE (rel->r_info))
+	    {
+	    case R_390_GOT12:
+            case R_390_GOT16:
+	    case R_390_GOT32:
+	    case R_390_GOTOFF:
+	    case R_390_GOTPC:
+	      elf_hash_table (info)->dynobj = dynobj = abfd;
+	      if (! _bfd_elf_create_got_section (dynobj, info))
+		return false;
+	      break;
+
+	    default:
+	      break;
+	    }
+	}
+
+
+      switch (ELF32_R_TYPE (rel->r_info))
+	{
+	case R_390_GOT12:
+        case R_390_GOT16:
+	case R_390_GOT32:
+	  /* This symbol requires a global offset table entry.  */
+
+	  if (sgot == NULL)
+	    {
+	      sgot = bfd_get_section_by_name (dynobj, ".got");
+	      BFD_ASSERT (sgot != NULL);
+	    }
+
+
+	  if (srelgot == NULL
+	      && (h != NULL || info->shared))
+	    {
+	      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+	      if (srelgot == NULL)
+		{
+		  srelgot = bfd_make_section (dynobj, ".rela.got");
+		  if (srelgot == NULL
+		      || ! bfd_set_section_flags (dynobj, srelgot,
+						  (SEC_ALLOC
+						   | SEC_LOAD
+						   | SEC_HAS_CONTENTS
+						   | SEC_IN_MEMORY
+						   | SEC_LINKER_CREATED
+						   | SEC_READONLY))
+		      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
+		    return false;
+		}
+	    }
+
+	  if (h != NULL)
+	    {
+	      if (h->got.refcount == -1)
+		{
+		  h->got.refcount = 1;
+
+		  /* Make sure this symbol is output as a dynamic symbol.  */
+		  if (h->dynindx == -1)
+		    {
+		      if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+			return false;
+		    }
+
+		  sgot->_raw_size += 4;
+		  srelgot->_raw_size += sizeof (Elf32_External_Rela);
+		}
+	      else
+		h->got.refcount += 1;
+	    }
+	  else
+	    {
+     	      /* This is a global offset table entry for a local symbol.  */
+	      if (local_got_refcounts == NULL)
+		{
+		  size_t size;
+
+		  size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
+		  local_got_refcounts = (bfd_signed_vma *)
+		                         bfd_alloc (abfd, size);
+		  if (local_got_refcounts == NULL)
+		    return false;
+		  elf_local_got_refcounts (abfd) = local_got_refcounts;
+		  memset (local_got_refcounts, -1, size);
+		}
+	      if (local_got_refcounts[r_symndx] == -1)
+		{
+		  local_got_refcounts[r_symndx] = 1;
+
+		  sgot->_raw_size += 4;
+		  if (info->shared)
+		    {
+		      /* If we are generating a shared object, we need to
+			 output a R_390_RELATIVE reloc so that the dynamic
+			 linker can adjust this GOT entry.  */
+		      srelgot->_raw_size += sizeof (Elf32_External_Rela);
+		    }
+		}
+	      else
+		local_got_refcounts[r_symndx] += 1;
+	    }
+	  break;
+
+        case R_390_PLT16DBL:
+	case R_390_PLT32:
+	  /* 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->plt.refcount == -1)
+	    {
+	      h->plt.refcount = 1;
+	      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	    }
+	  else
+	    h->plt.refcount += 1;
+	  break;
+
+        case R_390_8:
+        case R_390_16:
+	case R_390_32:
+        case R_390_PC16:
+        case R_390_PC16DBL:
+	case R_390_PC32:
+	  if (h != NULL)
+	    h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+
+	  /* 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
+             pcrel_relocs_copied field of the hash table entry.  */
+	  if (info->shared
+              && (sec->flags & SEC_ALLOC) != 0
+	      && ((ELF32_R_TYPE (rel->r_info) != R_390_PC16 &&
+                   ELF32_R_TYPE (rel->r_info) != R_390_PC16DBL &&
+                   ELF32_R_TYPE (rel->r_info) != R_390_PC32)
+		  || (h != NULL
+		      && (! info->symbolic
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0))))
+	    {
+	      /* 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;
+		    }
+		}
+
+	      sreloc->_raw_size += sizeof (Elf32_External_Rela);
+
+	      /* If we are linking with -Bsymbolic, and this is a
+                 global symbol, we count the number of PC relative
+                 relocations we have entered for this symbol, so that
+                 we can discard them again if the symbol is later
+                 defined by a regular object.  Note that this function
+                 is only called if we are using an elf_s390 linker
+                 hash table, which means that h is really a pointer to
+                 an elf_s390_link_hash_entry.  */
+	      if (h != NULL
+		  && (ELF32_R_TYPE (rel->r_info) == R_390_PC16 ||
+                      ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL ||
+                      ELF32_R_TYPE (rel->r_info) == R_390_PC32))
+		{
+		  struct elf_s390_link_hash_entry *eh;
+		  struct elf_s390_pcrel_relocs_copied *p;
+
+		  eh = (struct elf_s390_link_hash_entry *) h;
+
+		  for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
+		    if (p->section == sreloc)
+		      break;
+
+		  if (p == NULL)
+		    {
+		      p = ((struct elf_s390_pcrel_relocs_copied *)
+			   bfd_alloc (dynobj, sizeof *p));
+		      if (p == NULL)
+			return false;
+		      p->next = eh->pcrel_relocs_copied;
+		      eh->pcrel_relocs_copied = p;
+		      p->section = sreloc;
+		      p->count = 0;
+		    }
+
+		  ++p->count;
+		}
+	    }
+
+	  break;
+
+	  /* This relocation describes the C++ object vtable hierarchy.
+	     Reconstruct it for later use during GC.  */
+        case R_390_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_390_GNU_VTENTRY:
+          if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+            return false;
+          break;
+                   
+	default:
+	  break;
+	}
+    }
+
+  return true;
+}
+
+/* Return the section that should be marked against GC for a given
+   relocation.  */
+
+static asection *
+elf_s390_gc_mark_hook (abfd, info, rel, h, sym)
+     bfd *abfd;
+     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_390_GNU_VTINHERIT:
+	case R_390_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
+    {
+      if (!(elf_bad_symtab (abfd)
+	    && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
+	  && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
+		&& sym->st_shndx != SHN_COMMON))
+	{
+	  return bfd_section_from_elf_index (abfd, sym->st_shndx);
+	}
+    }
+
+  return NULL;
+}
+
+/* Update the got entry reference counts for the section being removed.  */
+
+static boolean
+elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     asection *sec ATTRIBUTE_UNUSED;
+     const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
+{
+  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;
+  bfd *dynobj;
+  asection *sgot;
+  asection *srelgot;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_refcounts = elf_local_got_refcounts (abfd);
+
+  dynobj = elf_hash_table (info)->dynobj;
+  if (dynobj == NULL)
+    return true;
+
+  sgot = bfd_get_section_by_name (dynobj, ".got");
+  srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+
+  relend = relocs + sec->reloc_count;
+  for (rel = relocs; rel < relend; rel++)
+    switch (ELF32_R_TYPE (rel->r_info))
+      {
+      case R_390_GOT12:
+      case R_390_GOT16:
+      case R_390_GOT32:
+      case R_390_GOTOFF:
+      case R_390_GOTPC:
+	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;
+		if (h->got.refcount == 0)
+		  {
+		    sgot->_raw_size -= 4;
+		    srelgot->_raw_size -= sizeof (Elf32_External_Rela);
+		  }
+	      }
+	  }
+	else if (local_got_refcounts != NULL)
+	  {
+	    if (local_got_refcounts[r_symndx] > 0)
+	      {
+		local_got_refcounts[r_symndx] -= 1;
+		if (local_got_refcounts[r_symndx] == 0)
+		  {
+		    sgot->_raw_size -= 4;
+		    if (info->shared)
+		      srelgot->_raw_size -= sizeof (Elf32_External_Rela);
+		  }
+	      }
+	  }
+	break;
+
+      case R_390_PLT16DBL:
+      case R_390_PLT32:
+	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;
+
+      default:
+	break;
+      }
+
+  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
+elf_s390_adjust_dynamic_symbol (info, h)
+     struct bfd_link_info *info;
+     struct elf_link_hash_entry *h;
+{
+  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
+     (although we could actually do it here). */
+  if (h->type == STT_FUNC
+      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
+    {
+      if ((! info->shared
+	   && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
+	   && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
+	  || (info->shared && h->plt.refcount <= 0))
+	{
+	  /* This case can occur if we saw a PLT32 reloc in an input
+             file, but the symbol was never referred to by a dynamic
+             object, or if all references were garbage collected.  In
+	     such a case, we don't actually need to build a procedure
+	     linkage table, and we can just do a PC32 reloc instead.  */
+	  h->plt.offset = (bfd_vma) -1;
+	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+	  return true;
+	}
+
+      /* Make sure this symbol is output as a dynamic symbol.  */
+      if (h->dynindx == -1)
+	{
+	  if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+	    return false;
+	}
+
+      s = bfd_get_section_by_name (dynobj, ".plt");
+      BFD_ASSERT (s != NULL);
+
+      /* The first entry in .plt is reserved.  */
+      if (s->_raw_size == 0)
+	s->_raw_size = PLT_FIRST_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
+       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 = s->_raw_size;
+      }
+
+      h->plt.offset = s->_raw_size;
+
+      /* 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.  */
+      s = bfd_get_section_by_name (dynobj, ".got.plt");
+      BFD_ASSERT (s != NULL);
+      s->_raw_size += GOT_ENTRY_SIZE;
+
+      /* We also need to make an entry in the .rela.plt section.  */
+      s = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (s != NULL);
+      s->_raw_size += sizeof (Elf32_External_Rela);
+
+      return true;
+    }
+
+  /* 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;
+
+  /* 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.  */
+
+  s = bfd_get_section_by_name (dynobj, ".dynbss");
+  BFD_ASSERT (s != NULL);
+
+  /* We must generate a R_390_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
+     .rel.bss section we are going to use.  */
+  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
+    {
+      asection *srel;
+
+      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
+      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;
+}
+
+/* Set the sizes of the dynamic sections.  */
+
+static boolean
+elf_s390_size_dynamic_sections (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  bfd *dynobj;
+  asection *s;
+  boolean reltext;
+  boolean relocs;
+  boolean plt;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  BFD_ASSERT (dynobj != NULL);
+
+  if (elf_hash_table (info)->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;
+	}
+    }
+  else
+    {
+      /* We may have created entries in the .rela.got section.
+         However, if we are not creating the dynamic sections, we will
+         not actually use these entries.  Reset the size of .rela.got,
+         which will cause it to get stripped from the output file
+         below.  */
+      s = bfd_get_section_by_name (dynobj, ".rela.got");
+      if (s != NULL)
+	s->_raw_size = 0;
+    }
+
+  /* If this is a -Bsymbolic shared link, then we need to discard all
+     PC relative relocs against symbols defined in a regular object.
+     We allocated space for them in the check_relocs routine, but we
+     will not fill them in in the relocate_section routine.  */
+  if (info->shared)
+    elf_s390_link_hash_traverse (elf_s390_hash_table (info),
+				 elf_s390_discard_copies,
+				 (PTR) info);
+
+  /* The check_relocs and adjust_dynamic_symbol entry points have
+     determined the sizes of the various dynamic sections.  Allocate
+     memory for them.  */
+  plt = false;
+  reltext = false;
+  relocs = false;
+  for (s = dynobj->sections; s != NULL; s = s->next)
+    {
+      const char *name;
+      boolean strip;
+
+      if ((s->flags & SEC_LINKER_CREATED) == 0)
+	continue;
+
+      /* It's OK to base decisions on the section name, because none
+	 of the dynobj section names depend upon the input files.  */
+      name = bfd_get_section_name (dynobj, s);
+
+      strip = false;
+
+      if (strcmp (name, ".plt") == 0)
+	{
+	  if (s->_raw_size == 0)
+	    {
+	      /* Strip this section if we don't need it; see the
+                 comment below.  */
+	      strip = true;
+	    }
+	  else
+	    {
+	      /* Remember whether there is a PLT.  */
+	      plt = true;
+	    }
+	}
+      else if (strncmp (name, ".rela", 5) == 0)
+	{
+	  if (s->_raw_size == 0)
+	    {
+	      /* If we don't need this section, strip it from the
+		 output file.  This is to handle .rela.bss and
+		 .rel.plt.  We must create it in
+		 create_dynamic_sections, because it 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.  */
+	      strip = true;
+	    }
+	  else
+	    {
+	      asection *target;
+
+	      /* Remember whether there are any reloc sections other
+                 than .rela.plt.  */
+	      if (strcmp (name, ".rela.plt") != 0)
+		{
+		  const char *outname;
+
+		  relocs = true;
+
+		  /* If this relocation section applies to a read only
+		     section, then we probably need a DT_TEXTREL
+		     entry.  The entries in the .rela.plt section
+		     really apply to the .got section, which we
+		     created ourselves and so know is not readonly.  */
+		  outname = bfd_get_section_name (output_bfd,
+						  s->output_section);
+		  target = bfd_get_section_by_name (output_bfd, outname + 5);
+		  if (target != NULL
+		      && (target->flags & SEC_READONLY) != 0
+		      && (target->flags & SEC_ALLOC) != 0)
+		    reltext = 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 if (strncmp (name, ".got", 4) != 0)
+	{
+	  /* It's not one of our sections, so don't allocate space.  */
+	  continue;
+	}
+
+      if (strip)
+	{
+	  _bfd_strip_section_from_output (info, s);
+	  continue;
+	}
+
+      /* Allocate memory for the section contents.  */
+      s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
+      if (s->contents == NULL && s->_raw_size != 0)
+	return false;
+    }
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      /* Add some entries to the .dynamic section.  We fill in the
+	 values later, in elf_s390_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.  */
+      if (! info->shared)
+	{
+	  if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
+	    return false;
+	}
+
+      if (plt)
+	{
+	  if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
+	      || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
+	      || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
+	      || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
+	    return false;
+	}
+
+      if (relocs)
+        {
+          if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
+              || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
+              || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
+					    sizeof (Elf32_External_Rela)))
+	    return false;
+         }
+
+      if (reltext)
+	{
+	  if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
+	    return false;
+	  info->flags |= DF_TEXTREL;
+	}
+    }
+
+  return true;
+}
+
+/* This function is called via elf_s390_link_hash_traverse if we are
+   creating a shared object with -Bsymbolic.  It discards the space
+   allocated to copy PC relative relocs against symbols which are
+   defined in regular objects.  We allocated space for them in the
+   check_relocs routine, but we won't fill them in in the
+   relocate_section routine.  */
+
+/*ARGSUSED*/
+static boolean
+elf_s390_discard_copies (h, inf)
+     struct elf_s390_link_hash_entry *h;
+     PTR inf;
+{
+  struct elf_s390_pcrel_relocs_copied *s;
+  struct bfd_link_info *info = (struct bfd_link_info *) inf;
+
+  /* If a symbol has been forced local or we have found a regular
+     definition for the symbolic link case, then we won't be needing
+     any relocs.  */
+  if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
+      && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
+	  || info->symbolic))
+    {
+      for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
+	s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
+    }
+  return true;
+}
+/* Relocate a 390 ELF section.  */
+
+static boolean
+elf_s390_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;
+{
+  bfd *dynobj;
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  bfd_vma *local_got_offsets;
+  asection *sgot;
+  asection *splt;
+  asection *sreloc;
+  Elf_Internal_Rela *rel;
+  Elf_Internal_Rela *relend;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (input_bfd);
+  local_got_offsets = elf_local_got_offsets (input_bfd);
+
+  sgot = NULL;
+  splt = NULL;
+  sreloc = NULL;
+  if (dynobj != NULL)
+    {
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      sgot = bfd_get_section_by_name (dynobj, ".got");
+    }
+
+  rel = relocs;
+  relend = relocs + input_section->reloc_count;
+  for (; rel < relend; rel++)
+    {
+      int r_type;
+      reloc_howto_type *howto;
+      unsigned long r_symndx;
+      struct elf_link_hash_entry *h;
+      Elf_Internal_Sym *sym;
+      asection *sec;
+      bfd_vma relocation;
+      bfd_reloc_status_type r;
+
+      r_type = ELF32_R_TYPE (rel->r_info);
+      if (r_type == (int) R_390_GNU_VTINHERIT
+          || r_type == (int) R_390_GNU_VTENTRY)
+        continue;
+      if (r_type < 0 || r_type >= (int) R_390_max)
+	{
+	  bfd_set_error (bfd_error_bad_value);
+	  return false;
+	}
+      howto = elf_howto_table + r_type;
+
+      r_symndx = ELF32_R_SYM (rel->r_info);
+
+      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.  */
+	  if (r_symndx < symtab_hdr->sh_info)
+	    {
+	      sym = local_syms + r_symndx;
+	      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+		{
+		  sec = local_sections[r_symndx];
+		  rel->r_addend += sec->output_offset + sym->st_value;
+		}
+	    }
+
+	  continue;
+	}
+
+      /* This is a final link.  */
+      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);
+	}
+      else
+	{
+	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    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)
+	    {
+	      sec = h->root.u.def.section;
+	      if (r_type == R_390_GOTPC
+		  || ((r_type == R_390_PLT16DBL ||
+                       r_type == R_390_PLT32)
+		      && splt != NULL
+		      && h->plt.offset != (bfd_vma) -1)
+		  || ((r_type == R_390_GOT12 ||
+                       r_type == R_390_GOT16 ||
+                       r_type == R_390_GOT32)
+		      && elf_hash_table (info)->dynamic_sections_created
+		      && (! info->shared
+			  || (! info->symbolic && h->dynindx != -1)
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0))
+		  || (info->shared
+		      && ((! info->symbolic && h->dynindx != -1)
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0)
+		      && ( r_type == R_390_8 ||
+			   r_type == R_390_16 ||
+                           r_type == R_390_32 ||
+                           r_type == R_390_PC16 ||
+                           r_type == R_390_PC16DBL ||
+                           r_type == R_390_PC32)
+                      && ((input_section->flags & SEC_ALLOC) != 0
+                          /* DWARF will emit R_386_32 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))))
+		{
+		  /* In these cases, we don't need the relocation
+                     value.  We check specially because in some
+                     obscure cases sec->output_section will be NULL.  */
+		  relocation = 0;
+		}
+	      else if (sec->output_section == NULL)
+		{
+		  (*_bfd_error_handler)
+		    (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
+		     bfd_get_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);
+	    }
+	  else if (h->root.type == bfd_link_hash_undefweak)
+	    relocation = 0;
+	  else if (info->shared && !info->symbolic
+		   && !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 (r_type)
+	{
+        case R_390_GOT12:
+        case R_390_GOT16:
+        case R_390_GOT32:
+          /* Relocation is to the entry for this symbol in the global
+             offset table.  */
+	  BFD_ASSERT (sgot != NULL);
+
+          if (h != NULL)
+            {
+              bfd_vma off;
+
+              off = h->got.offset;
+              BFD_ASSERT (off != (bfd_vma) -1);
+
+              if (! elf_hash_table (info)->dynamic_sections_created
+                  || (info->shared
+                      && (info->symbolic || h->dynindx == -1)
+                      && (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 2, we use the
+                     least significant bit to record whether we have
+                     initialized it already.
+
+                     When doing a dynamic link, we create a .rel.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);
+                      h->got.offset |= 1;
+                    }
+                }
+	      relocation = sgot->output_offset + off;
+            }
+          else
+            {
+              bfd_vma off;
+
+              BFD_ASSERT (local_got_offsets != NULL
+                          && local_got_offsets[r_symndx] != (bfd_vma) -1);
+
+              off = local_got_offsets[r_symndx];
+
+              /* 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_390_RELATIVE);
+		      outrel.r_addend = relocation;
+                      bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+                                                (((Elf32_External_Rela *)
+                                                  srelgot->contents)
+                                                 + srelgot->reloc_count));
+                      ++srelgot->reloc_count;
+                    }
+
+                  local_got_offsets[r_symndx] |= 1;
+                }
+
+	      relocation = sgot->output_offset + off;
+            }
+
+
+          break;
+ 
+        case R_390_GOTOFF:
+          /* Relocation is relative to the start of the global offset
+             table.  */
+
+          if (sgot == NULL)
+            {
+              sgot = bfd_get_section_by_name (dynobj, ".got");
+              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;
+
+          break;
+
+        case R_390_GOTPC:
+          /* Use global offset table as symbol value.  */
+
+          if (sgot == NULL)
+            {
+              sgot = bfd_get_section_by_name (dynobj, ".got");
+              BFD_ASSERT (sgot != NULL);
+            }
+
+          relocation = sgot->output_section->vma;
+
+          break;
+
+        case R_390_PLT16DBL:
+        case R_390_PLT32:
+          /* Relocation is to the entry for this symbol in the
+             procedure linkage table.  */
+
+          /* Resolve a PLT32 reloc against a local symbol directly,
+             without using the procedure linkage table.  */
+          if (h == NULL)
+            break;
+
+          if (h->plt.offset == (bfd_vma) -1 || splt == NULL)
+            {
+              /* We didn't make a PLT entry for this symbol.  This
+                 happens when statically linking PIC code, or when
+                 using -Bsymbolic.  */
+              break;
+            }
+
+          relocation = (splt->output_section->vma
+                        + splt->output_offset
+                        + h->plt.offset);
+
+          break;
+
+        case R_390_8:
+        case R_390_16:
+        case R_390_32:
+        case R_390_PC16:
+        case R_390_PC16DBL:
+        case R_390_PC32:
+          if (info->shared
+              && (input_section->flags & SEC_ALLOC) != 0
+              && ((r_type != R_390_PC16 &&
+                   r_type != R_390_PC16DBL &&
+                   r_type != R_390_PC32)
+                  || (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;
+
+              if (elf_section_data (input_section)->stab_info == NULL)
+                outrel.r_offset = rel->r_offset;
+              else
+                {
+                  bfd_vma off;
+
+                  off = (_bfd_stab_section_offset
+                         (output_bfd, &elf_hash_table (info)->stab_info,
+                          input_section,
+                          &elf_section_data (input_section)->stab_info,
+                          rel->r_offset));
+                  if (off == (bfd_vma) -1)
+                    skip = true;
+                  outrel.r_offset = off;
+                }
+
+              outrel.r_offset += (input_section->output_section->vma
+                                  + input_section->output_offset);
+
+              if (skip)
+                {
+                  memset (&outrel, 0, sizeof outrel);
+                  relocate = false;
+                }
+              else if (r_type == R_390_PC16 ||
+                       r_type == R_390_PC16DBL ||
+                       r_type == R_390_PC32)
+                {
+                  BFD_ASSERT (h != NULL && h->dynindx != -1);
+		  relocate = false;
+                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
+		  outrel.r_addend = relocation + rel->r_addend;
+                }
+              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_390_RELATIVE);
+		      outrel.r_addend = relocation + rel->r_addend;
+                    }
+		  else
+		    {
+		      BFD_ASSERT (h->dynindx != -1);
+		      relocate = false;
+		      outrel.r_info = ELF32_R_INFO (h->dynindx, R_390_32);
+		      outrel.r_addend = relocation + rel->r_addend;
+		    }
+                }
+
+              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;
+            }
+
+          break;
+
+        default:
+          break;
+        }
+
+      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+				      contents, rel->r_offset,
+				      relocation, rel->r_addend);
+
+      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;
+}
+
+/* Finish up dynamic symbol handling.  We set the contents of various
+   dynamic sections here.  */
+
+static boolean
+elf_s390_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;
+{
+  bfd *dynobj;
+
+  dynobj = elf_hash_table (info)->dynobj;
+
+  if (h->plt.offset != (bfd_vma) -1)
+    {
+      asection *splt;
+      asection *srela;
+      Elf_Internal_Rela rela;
+      bfd_vma relative_offset;
+      bfd_vma got_offset;
+      bfd_vma plt_index;
+      asection *sgot;
+
+      /* This symbol has an entry in the procedure linkage table.  Set
+         it up.  */
+
+      BFD_ASSERT (h->dynindx != -1);
+
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
+      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
+
+      /* Calc. index no. 
+         Current offset - size first entry / entry size.  */
+      plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
+
+      /* Offset in GOT is PLT index plus GOT headers(3) times 4,
+         addr & GOT addr.  */
+      got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
+
+      /* S390 uses halfwords for relative branch calc!  */
+      relative_offset = - ((PLT_FIRST_ENTRY_SIZE + 
+                           (PLT_ENTRY_SIZE * plt_index) + 18)/2);
+      /* If offset is > 32768, branch to a previous branch
+         390 can only handle +-64 K jumps.  */
+      if ( -32768 > (int)relative_offset )
+          relative_offset = -(((65536/PLT_ENTRY_SIZE-1)*PLT_ENTRY_SIZE)/2);
+
+      /* Fill in the entry in the procedure linkage table.  */
+      if (!info->shared)
+       {
+        bfd_put_32 (output_bfd, PLT_ENTRY_WORD0,
+                    splt->contents + h->plt.offset);
+        bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
+                    splt->contents + h->plt.offset + 4);
+        bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
+                    splt->contents + h->plt.offset + 8);
+        bfd_put_32 (output_bfd, PLT_ENTRY_WORD3,
+                    splt->contents + h->plt.offset + 12);
+        bfd_put_32 (output_bfd, PLT_ENTRY_WORD4,
+                    splt->contents + h->plt.offset + 16);
+        bfd_put_32 (output_bfd, 0+(relative_offset << 16),
+                    splt->contents + h->plt.offset + 20);
+        bfd_put_32 (output_bfd,
+                    (sgot->output_section->vma +
+                     sgot->output_offset +
+                     got_offset),
+                     splt->contents + h->plt.offset + 24);
+       }
+      else if (got_offset < 4096)
+       {
+        bfd_put_32 (output_bfd, PLT_PIC12_ENTRY_WORD0 + got_offset,
+                    splt->contents + h->plt.offset);
+        bfd_put_32 (output_bfd, PLT_PIC12_ENTRY_WORD1,
+                    splt->contents + h->plt.offset + 4);
+        bfd_put_32 (output_bfd, PLT_PIC12_ENTRY_WORD2,
+                    splt->contents + h->plt.offset + 8);
+        bfd_put_32 (output_bfd, PLT_PIC12_ENTRY_WORD3,
+                    splt->contents + h->plt.offset + 12);
+        bfd_put_32 (output_bfd, PLT_PIC12_ENTRY_WORD4,
+                    splt->contents + h->plt.offset + 16);
+        bfd_put_32 (output_bfd, 0+(relative_offset << 16),
+                    splt->contents + h->plt.offset + 20);
+        bfd_put_32 (output_bfd, 0,
+                    splt->contents + h->plt.offset + 24);
+       }
+      else if (got_offset < 32768)
+       {
+        bfd_put_32 (output_bfd, PLT_PIC16_ENTRY_WORD0 + got_offset,
+                    splt->contents + h->plt.offset);
+        bfd_put_32 (output_bfd, PLT_PIC16_ENTRY_WORD1,
+                    splt->contents + h->plt.offset + 4);
+        bfd_put_32 (output_bfd, PLT_PIC16_ENTRY_WORD2,
+                    splt->contents + h->plt.offset + 8);
+        bfd_put_32 (output_bfd, PLT_PIC16_ENTRY_WORD3,
+                    splt->contents + h->plt.offset + 12);
+        bfd_put_32 (output_bfd, PLT_PIC16_ENTRY_WORD4,
+                    splt->contents + h->plt.offset + 16);
+        bfd_put_32 (output_bfd, 0+(relative_offset << 16),
+                    splt->contents + h->plt.offset + 20);
+        bfd_put_32 (output_bfd, 0,
+                    splt->contents + h->plt.offset + 24);
+       }
+      else
+       {
+        bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD0,
+		    splt->contents + h->plt.offset);
+        bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD1,
+		    splt->contents + h->plt.offset + 4);
+        bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD2,
+		    splt->contents + h->plt.offset + 8);
+        bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD3, 
+		    splt->contents + h->plt.offset + 12);
+        bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD4,
+		    splt->contents + h->plt.offset + 16);
+        bfd_put_32 (output_bfd, 0+(relative_offset << 16),
+		    splt->contents + h->plt.offset + 20);
+        bfd_put_32 (output_bfd, got_offset,
+		    splt->contents + h->plt.offset + 24);
+       }
+      /* Insert offset into  reloc. table here.  */
+      bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
+                  splt->contents + h->plt.offset + 28);
+      /* Fill in the entry in the .rela.plt section.  */
+      rela.r_offset = (sgot->output_section->vma
+		       + sgot->output_offset
+		       + got_offset);
+      rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
+      rela.r_addend = 0;
+      bfd_elf32_swap_reloca_out (output_bfd, &rela,
+				 ((Elf32_External_Rela *) srela->contents
+				  + plt_index ));
+
+      /* Fill in the entry in the global offset table.
+         Points to instruction after GOT offset.  */
+      bfd_put_32 (output_bfd,
+		  (splt->output_section->vma
+		   + splt->output_offset
+		   + h->plt.offset
+		   + 12),
+		  sgot->contents + got_offset);
+
+
+      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 *srela;
+      Elf_Internal_Rela rela;
+
+      /* This symbol has an entry in the global offset table.  Set it
+         up.  */
+
+      sgot = bfd_get_section_by_name (dynobj, ".got");
+      srela = bfd_get_section_by_name (dynobj, ".rela.got");
+      BFD_ASSERT (sgot != NULL && srela != NULL);
+
+      rela.r_offset = (sgot->output_section->vma
+		       + sgot->output_offset
+		       + (h->got.offset &~ 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 (! elf_hash_table (info)->dynamic_sections_created
+	  || (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_390_RELATIVE);
+          rela.r_addend = (h->root.u.def.value
+                           + h->root.u.def.section->output_section->vma
+                           + h->root.u.def.section->output_offset);
+        }
+      else
+	{
+	  BFD_ASSERT((h->got.offset & 1) == 0);
+	  bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
+	  rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
+          rela.r_addend = 0;
+        }
+
+      bfd_elf32_swap_reloca_out (output_bfd, &rela,
+				 ((Elf32_External_Rela *) srela->contents
+				  + srela->reloc_count));
+      ++srela->reloc_count;
+    }
+
+  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
+    {
+      asection *s;
+      Elf_Internal_Rela rela;
+
+      /* This symbols 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);
+
+      rela.r_offset = (h->root.u.def.value
+		       + h->root.u.def.section->output_section->vma
+		       + h->root.u.def.section->output_offset);
+      rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
+      rela.r_addend = 0;
+      bfd_elf32_swap_reloca_out (output_bfd, &rela,
+				 ((Elf32_External_Rela *) s->contents
+				  + s->reloc_count));
+      ++s->reloc_count;
+    }
+
+  /* Mark some specially defined symbols as absolute.  */
+  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+      || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
+      || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
+    sym->st_shndx = SHN_ABS;
+
+  return true;
+}
+
+/* Finish up the dynamic sections.  */
+
+static boolean
+elf_s390_finish_dynamic_sections (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  bfd *dynobj;
+  asection *sdyn;
+  asection *sgot;
+
+  dynobj = elf_hash_table (info)->dynobj;
+
+  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
+  BFD_ASSERT (sgot != NULL);
+  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      asection *splt;
+      Elf32_External_Dyn *dyncon, *dynconend;
+
+      BFD_ASSERT (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;
+	  const char *name;
+	  asection *s;
+
+	  bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
+
+	  switch (dyn.d_tag)
+	    {
+	    default:
+	      break;
+
+	    case DT_PLTGOT:
+	      name = ".got";
+	      goto get_vma;
+	    case DT_JMPREL:
+	      name = ".rela.plt";
+	    get_vma:
+	      s = bfd_get_section_by_name(output_bfd, name);
+	      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 = bfd_get_section_by_name (output_bfd, ".rela.plt");
+	      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;
+	    }
+	}
+
+      /* Fill in the special first entry in the procedure linkage table.  */
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      if (splt && splt->_raw_size > 0)
+	{
+          memset (splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
+          if (info->shared)
+           {
+	      bfd_put_32 (output_bfd, PLT_PIC_FIRST_ENTRY_WORD0,
+		          splt->contents );
+	      bfd_put_32 (output_bfd, PLT_PIC_FIRST_ENTRY_WORD1,
+		          splt->contents +4 );
+	      bfd_put_32 (output_bfd, PLT_PIC_FIRST_ENTRY_WORD2,
+		          splt->contents +8 );
+	      bfd_put_32 (output_bfd, PLT_PIC_FIRST_ENTRY_WORD3,
+		          splt->contents +12 );
+	      bfd_put_32 (output_bfd, PLT_PIC_FIRST_ENTRY_WORD4,
+		          splt->contents +16 );
+           }
+          else
+           {
+              bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD0,
+                          splt->contents );
+              bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD1,
+                          splt->contents +4 );
+              bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD2,
+                          splt->contents +8 );
+              bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD3,
+                          splt->contents +12 );
+              bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD4,
+                          splt->contents +16 );
+              bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD5,
+                          splt->contents +20 );
+              bfd_put_32 (output_bfd,
+                          sgot->output_section->vma + sgot->output_offset,
+                          splt->contents + 24);
+           }
+	  elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
+	}
+
+    }
+
+  /* Set the first entry in the global offset table to the address of
+     the dynamic section.  */
+  if (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);
+
+      /* One entry for shared object struct ptr.  */
+      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
+      /* One entry for _dl_runtime_resolve.  */
+      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 boolean
+elf_s390_object_p (abfd)
+     bfd *abfd;
+{
+  return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_esa);
+}
+
+#define TARGET_BIG_SYM	bfd_elf32_s390_vec
+#define TARGET_BIG_NAME	"elf32-s390"
+#define ELF_ARCH	bfd_arch_s390
+#define ELF_MACHINE_CODE EM_S390
+#define ELF_MACHINE_ALT1 EM_S390_OLD
+#define ELF_MAXPAGESIZE 0x1000
+
+#define elf_backend_can_gc_sections	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
+
+#define elf_info_to_howto                     elf_s390_info_to_howto
+
+#define bfd_elf32_bfd_final_link	      _bfd_elf32_gc_common_final_link
+#define bfd_elf32_bfd_is_local_label_name     elf_s390_is_local_label_name
+#define bfd_elf32_bfd_link_hash_table_create  elf_s390_link_hash_table_create
+#define bfd_elf32_bfd_reloc_type_lookup	      elf_s390_reloc_type_lookup
+
+#define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
+#define elf_backend_check_relocs              elf_s390_check_relocs
+#define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
+#define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
+#define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
+#define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
+#define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
+#define elf_backend_relocate_section          elf_s390_relocate_section
+#define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
+
+#define elf_backend_object_p            elf_s390_object_p
+
+#include "elf32-target.h"
diff --git a/bfd/elf64-s390.c b/bfd/elf64-s390.c
new file mode 100644
index 0000000..9296a26
--- /dev/null
+++ b/bfd/elf64-s390.c
@@ -0,0 +1,2178 @@
+/* IBM S/390-specific support for 64-bit ELF
+   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+   Contributed Martin Schwidefsky (schwidefsky@de.ibm.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 "bfdlink.h"
+#include "libbfd.h"
+#include "elf-bfd.h"
+
+static reloc_howto_type *elf_s390_reloc_type_lookup
+  PARAMS ((bfd *, bfd_reloc_code_real_type));
+static void elf_s390_info_to_howto
+  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
+static boolean elf_s390_is_local_label_name PARAMS ((bfd *, const char *));
+static struct bfd_hash_entry *elf_s390_link_hash_newfunc
+  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
+static struct bfd_link_hash_table *elf_s390_link_hash_table_create
+  PARAMS ((bfd *));
+static boolean elf_s390_check_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection *,
+	   const Elf_Internal_Rela *));
+static boolean elf_s390_adjust_dynamic_symbol
+  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+static boolean elf_s390_size_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static boolean elf_s390_relocate_section
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+	   Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
+static boolean elf_s390_finish_dynamic_symbol
+  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
+	   Elf_Internal_Sym *));
+static boolean elf_s390_finish_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+
+#define USE_RELA 1		/* We want RELA relocations, not REL.  */
+
+#include "elf/s390.h"
+
+/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
+   from smaller values.  Start with zero, widen, *then* decrement.  */
+#define MINUS_ONE      (((bfd_vma)0) - 1)
+
+/* The relocation "howto" table.  */
+static reloc_howto_type elf_howto_table[] =
+{
+  HOWTO (R_390_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 */
+	 bfd_elf_generic_reloc, /* special_function */
+	 "R_390_NONE",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  HOWTO(R_390_8,         0, 0,  8, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_8",       false, 0,0x000000ff, false),
+  HOWTO(R_390_12,        0, 1, 12, false, 0, complain_overflow_dont, bfd_elf_generic_reloc, "R_390_12",      false, 0,0x00000fff, false),
+  HOWTO(R_390_16,        0, 1, 16, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_16",      false, 0,0x0000ffff, false),
+  HOWTO(R_390_32,        0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_32",      false, 0,0xffffffff, false),
+  HOWTO(R_390_PC32,	 0, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC32",    false, 0,0xffffffff,  true),
+  HOWTO(R_390_GOT12,	 0, 1, 12, false, 0, complain_overflow_dont, bfd_elf_generic_reloc, "R_390_GOT12",   false, 0,0x00000fff, false),
+  HOWTO(R_390_GOT32,	 0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT32",   false, 0,0xffffffff, false),
+  HOWTO(R_390_PLT32,	 0, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT32",   false, 0,0xffffffff,  true),
+  HOWTO(R_390_COPY,      0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_COPY",    false, 0,MINUS_ONE, false),
+  HOWTO(R_390_GLOB_DAT,  0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GLOB_DAT",false, 0,MINUS_ONE, false),
+  HOWTO(R_390_JMP_SLOT,  0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_JMP_SLOT",false, 0,MINUS_ONE, false),
+  HOWTO(R_390_RELATIVE,  0, 4, 64,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_RELATIVE",false, 0,MINUS_ONE, false),
+  HOWTO(R_390_GOTOFF,    0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTOFF",  false, 0,MINUS_ONE, false),
+  HOWTO(R_390_GOTPC,     0, 4, 64,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTPC",   false, 0,MINUS_ONE,  true),
+  HOWTO(R_390_GOT16,     0, 1, 16, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT16",   false, 0,0x0000ffff, false),
+  HOWTO(R_390_PC16,      0, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC16",    false, 0,0x0000ffff,  true),
+  HOWTO(R_390_PC16DBL,   1, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC16DBL", false, 0,0x0000ffff,  true),
+  HOWTO(R_390_PLT16DBL,  1, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT16DBL", false, 0,0x0000ffff,  true),
+  HOWTO(R_390_PC32DBL,	 1, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC32DBL", false, 0,0xffffffff,  true),
+  HOWTO(R_390_PLT32DBL,	 1, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT32DBL", false, 0,0xffffffff,  true),
+  HOWTO(R_390_GOTPCDBL,  1, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTPCDBL", false, 0,MINUS_ONE,  true),
+  HOWTO(R_390_64,        0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_64",      false, 0,MINUS_ONE, false),
+  HOWTO(R_390_PC64,	 0, 4, 64,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC64",    false, 0,MINUS_ONE,  true),
+  HOWTO(R_390_GOT64,	 0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT64",   false, 0,MINUS_ONE, false),
+  HOWTO(R_390_PLT64,	 0, 4, 64,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT64",   false, 0,MINUS_ONE,  true),
+  HOWTO(R_390_GOTENT,	 1, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTENT",   false, 0,MINUS_ONE,  true),
+};
+
+/* GNU extension to record C++ vtable hierarchy.  */
+static reloc_howto_type elf64_s390_vtinherit_howto =
+  HOWTO (R_390_GNU_VTINHERIT, 0,4,0,false,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", false,0, 0, false);
+static reloc_howto_type elf64_s390_vtentry_howto =
+  HOWTO (R_390_GNU_VTENTRY, 0,4,0,false,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_390_GNU_VTENTRY", false,0,0, false); 
+
+static reloc_howto_type *
+elf_s390_reloc_type_lookup (abfd, code)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     bfd_reloc_code_real_type code;
+{
+  switch (code) {
+  case BFD_RELOC_NONE:
+    return &elf_howto_table[(int) R_390_NONE];
+  case BFD_RELOC_8:
+    return &elf_howto_table[(int) R_390_8];
+  case BFD_RELOC_390_12:
+    return &elf_howto_table[(int) R_390_12];
+  case BFD_RELOC_16:
+    return &elf_howto_table[(int) R_390_16];
+  case BFD_RELOC_32:
+    return &elf_howto_table[(int) R_390_32];
+  case BFD_RELOC_CTOR:
+    return &elf_howto_table[(int) R_390_32];
+  case BFD_RELOC_32_PCREL:
+    return &elf_howto_table[(int) R_390_PC32];
+  case BFD_RELOC_390_GOT12:
+    return &elf_howto_table[(int) R_390_GOT12];
+  case BFD_RELOC_32_GOT_PCREL:
+    return &elf_howto_table[(int) R_390_GOT32];
+  case BFD_RELOC_390_PLT32:
+    return &elf_howto_table[(int) R_390_PLT32];
+  case BFD_RELOC_390_COPY:
+    return &elf_howto_table[(int) R_390_COPY];
+  case BFD_RELOC_390_GLOB_DAT:
+    return &elf_howto_table[(int) R_390_GLOB_DAT];
+  case BFD_RELOC_390_JMP_SLOT:
+    return &elf_howto_table[(int) R_390_JMP_SLOT];
+  case BFD_RELOC_390_RELATIVE:
+    return &elf_howto_table[(int) R_390_RELATIVE];
+  case BFD_RELOC_32_GOTOFF:
+    return &elf_howto_table[(int) R_390_GOTOFF];
+  case BFD_RELOC_390_GOTPC:
+    return &elf_howto_table[(int) R_390_GOTPC];
+  case BFD_RELOC_390_GOT16:
+    return &elf_howto_table[(int) R_390_GOT16];
+  case BFD_RELOC_16_PCREL:
+    return &elf_howto_table[(int) R_390_PC16];
+  case BFD_RELOC_390_PC16DBL:
+    return &elf_howto_table[(int) R_390_PC16DBL];
+  case BFD_RELOC_390_PLT16DBL:
+    return &elf_howto_table[(int) R_390_PLT16DBL];
+  case BFD_RELOC_VTABLE_INHERIT:
+    return &elf64_s390_vtinherit_howto;
+  case BFD_RELOC_VTABLE_ENTRY:
+    return &elf64_s390_vtentry_howto;
+  case BFD_RELOC_390_PC32DBL:
+    return &elf_howto_table[(int) R_390_PC32DBL];
+  case BFD_RELOC_390_PLT32DBL:
+    return &elf_howto_table[(int) R_390_PLT32DBL];
+  case BFD_RELOC_390_GOTPCDBL:
+    return &elf_howto_table[(int) R_390_GOTPCDBL];
+  case BFD_RELOC_64:
+    return &elf_howto_table[(int) R_390_64];
+  case BFD_RELOC_64_PCREL:
+    return &elf_howto_table[(int) R_390_PC64];
+  case BFD_RELOC_390_GOT64:
+    return &elf_howto_table[(int) R_390_GOT64];
+  case BFD_RELOC_390_PLT64:
+    return &elf_howto_table[(int) R_390_PLT64];
+  case BFD_RELOC_390_GOTENT:
+    return &elf_howto_table[(int) R_390_GOTENT];
+  default:
+    break;                                         
+  }
+  return 0;
+}
+
+/* We need to use ELF64_R_TYPE so we have our own copy of this function,
+   and elf64-s390.c has its own copy.  */
+
+static void
+elf_s390_info_to_howto (abfd, cache_ptr, dst)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     arelent *cache_ptr;
+     Elf_Internal_Rela *dst;
+{
+  switch (ELF64_R_TYPE(dst->r_info))
+    {
+    case R_390_GNU_VTINHERIT:
+      cache_ptr->howto = &elf64_s390_vtinherit_howto;
+      break;
+
+    case R_390_GNU_VTENTRY:
+      cache_ptr->howto = &elf64_s390_vtentry_howto;
+      break;
+
+    default:
+      BFD_ASSERT (ELF64_R_TYPE(dst->r_info) < (unsigned int) R_390_max);
+      cache_ptr->howto = &elf_howto_table[ELF64_R_TYPE(dst->r_info)];
+    }     
+}
+
+static boolean
+elf_s390_is_local_label_name (abfd, name)
+     bfd *abfd;
+     const char *name;
+{
+  if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
+    return true;
+
+  return _bfd_elf_is_local_label_name (abfd, name);
+}
+
+/* Functions for the 390 ELF linker.  */
+
+/* The name of the dynamic interpreter.  This is put in the .interp
+   section.  */
+
+#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
+
+/* The nop opcode we use.  */
+
+#define s390_NOP 0x07070707
+
+
+/* The size in bytes of the first entry in the procedure linkage table.  */
+#define PLT_FIRST_ENTRY_SIZE 32
+/* The size in bytes of an entry in the procedure linkage table.  */
+#define PLT_ENTRY_SIZE 32 
+
+#define GOT_ENTRY_SIZE 8
+
+/* The first three entries in a procedure linkage table are reserved,
+   and the initial contents are unimportant (we zero them out).
+   Subsequent entries look like this.  See the SVR4 ABI 386
+   supplement to see how this works.  */
+
+/* For the s390, simple addr offset can only be 0 - 4096.
+   To use the full 16777216 TB address space, several instructions
+   are needed to load an address in a register and execute
+   a branch( or just saving the address)
+
+   Furthermore, only r 0 and 1 are free to use!!!  */ 
+
+/* The first 3 words in the GOT are then reserved.
+   Word 0 is the address of the dynamic table.
+   Word 1 is a pointer to a structure describing the object
+   Word 2 is used to point to the loader entry address.
+
+   The code for PLT entries looks like this:
+
+   The GOT holds the address in the PLT to be executed.
+   The loader then gets:
+   24(15) =  Pointer to the structure describing the object.
+   28(15) =  Offset in symbol table                                             
+   The loader  must  then find the module where the function is
+   and insert the address in the GOT.
+
+   PLT1: LARL 1,<fn>@GOTENT # 6 bytes  Load address of GOT entry in r1
+         LG   1,0(1)      # 6 bytes  Load address from GOT in r1
+         BCR  15,1        # 2 bytes  Jump to address
+   RET1: BASR 1,0         # 2 bytes  Return from GOT 1st time
+         LGF  1,12(1)     # 6 bytes  Load offset in symbl table in r1
+         BRCL 15,-x       # 6 bytes  Jump to start of PLT
+         .long ?          # 4 bytes  offset into symbol table
+
+   Total = 32 bytes per PLT entry
+   Fixup at offset 2: relative address to GOT entry
+   Fixup at offset 22: relative branch to PLT0
+   Fixup at offset 28: 32 bit offset into symbol table
+
+   A 32 bit offset into the symbol table is enough. It allows for symbol
+   tables up to a size of 2 gigabyte. A single dynamic object (the main
+   program, any shared library) is limited to 4GB in size and I want to see
+   the program that manages to have a symbol table of more than 2 GB with a
+   total size of at max 4 GB.  */
+
+#define PLT_ENTRY_WORD0     0xc0100000
+#define PLT_ENTRY_WORD1     0x0000e310
+#define PLT_ENTRY_WORD2     0x10000004
+#define PLT_ENTRY_WORD3     0x07f10d10
+#define PLT_ENTRY_WORD4     0xe310100c
+#define PLT_ENTRY_WORD5     0x0014c0f4
+#define PLT_ENTRY_WORD6     0x00000000
+#define PLT_ENTRY_WORD7     0x00000000
+
+/* The first PLT entry pushes the offset into the symbol table
+   from R1 onto the stack at 8(15) and the loader object info
+   at 12(15), loads the loader address in R1 and jumps to it.  */
+
+/* The first entry in the PLT:
+
+  PLT0:
+     STG  1,56(15)  # r1 contains the offset into the symbol table
+     LARL 1,_GLOBAL_OFFSET_TABLE # load address of global offset table
+     MVC  48(8,15),8(1) # move loader ino (object struct address) to stack
+     LG   1,16(1)   # get entry address of loader
+     BCR  15,1      # jump to loader
+
+     Fixup at offset 8: relative address to start of GOT.  */
+
+#define PLT_FIRST_ENTRY_WORD0     0xe310f038
+#define PLT_FIRST_ENTRY_WORD1     0x0024c010
+#define PLT_FIRST_ENTRY_WORD2     0x00000000
+#define PLT_FIRST_ENTRY_WORD3     0xd207f030
+#define PLT_FIRST_ENTRY_WORD4     0x1008e310
+#define PLT_FIRST_ENTRY_WORD5     0x10100004
+#define PLT_FIRST_ENTRY_WORD6     0x07f10700
+#define PLT_FIRST_ENTRY_WORD7     0x07000700
+
+/* The s390 linker needs to keep track of the number of relocs that it
+   decides to copy in check_relocs for each symbol.  This is so that
+   it can discard PC relative relocs if it doesn't need them when
+   linking with -Bsymbolic.  We store the information in a field
+   extending the regular ELF linker hash table.  */
+
+/* This structure keeps track of the number of PC relative relocs we
+   have copied for a given symbol.  */
+
+struct elf_s390_pcrel_relocs_copied
+{
+  /* Next section.  */
+  struct elf_s390_pcrel_relocs_copied *next;
+  /* A section in dynobj.  */
+  asection *section;
+  /* Number of relocs copied in this section.  */
+  bfd_size_type count;
+};
+
+/* s390 ELF linker hash entry.  */
+
+struct elf_s390_link_hash_entry
+{
+  struct elf_link_hash_entry root;
+
+  /* Number of PC relative relocs copied for this symbol.  */
+  struct elf_s390_pcrel_relocs_copied *pcrel_relocs_copied;
+};
+
+/* s390 ELF linker hash table.  */
+
+struct elf_s390_link_hash_table
+{
+  struct elf_link_hash_table root;
+};
+
+/* Declare this now that the above structures are defined.  */
+
+static boolean elf_s390_discard_copies
+  PARAMS ((struct elf_s390_link_hash_entry *, PTR));
+
+/* Traverse an s390 ELF linker hash table.  */
+
+#define elf_s390_link_hash_traverse(table, func, info)		\
+  (elf_link_hash_traverse						\
+   (&(table)->root,							\
+    (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),	\
+    (info)))
+
+/* Get the s390 ELF linker hash table from a link_info structure.  */
+
+#define elf_s390_hash_table(p) \
+  ((struct elf_s390_link_hash_table *) ((p)->hash))
+
+/* Create an entry in an s390 ELF linker hash table.  */
+
+static struct bfd_hash_entry *
+elf_s390_link_hash_newfunc (entry, table, string)
+     struct bfd_hash_entry *entry;
+     struct bfd_hash_table *table;
+     const char *string;
+{
+  struct elf_s390_link_hash_entry *ret =
+    (struct elf_s390_link_hash_entry *) entry;
+
+  /* Allocate the structure if it has not already been allocated by a
+     subclass.  */
+  if (ret == (struct elf_s390_link_hash_entry *) NULL)
+    ret = ((struct elf_s390_link_hash_entry *)
+	   bfd_hash_allocate (table,
+			      sizeof (struct elf_s390_link_hash_entry)));
+  if (ret == (struct elf_s390_link_hash_entry *) NULL)
+    return (struct bfd_hash_entry *) ret;
+
+  /* Call the allocation method of the superclass.  */
+  ret = ((struct elf_s390_link_hash_entry *)
+	 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
+				     table, string));
+  if (ret != (struct elf_s390_link_hash_entry *) NULL)
+    {
+      ret->pcrel_relocs_copied = NULL;
+    }
+
+  return (struct bfd_hash_entry *) ret;
+}
+
+/* Create an s390 ELF linker hash table.  */
+
+static struct bfd_link_hash_table *
+elf_s390_link_hash_table_create (abfd)
+     bfd *abfd;
+{
+  struct elf_s390_link_hash_table *ret;
+
+  ret = ((struct elf_s390_link_hash_table *)
+	 bfd_alloc (abfd, sizeof (struct elf_s390_link_hash_table)));
+  if (ret == (struct elf_s390_link_hash_table *) NULL)
+    return NULL;
+
+  if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
+				       elf_s390_link_hash_newfunc))
+    {
+      bfd_release (abfd, ret);
+      return NULL;
+    }
+
+  return &ret->root.root;
+}
+
+
+/* Look through the relocs for a section during the first phase, and
+   allocate space in the global offset table or procedure linkage
+   table.  */
+
+static boolean
+elf_s390_check_relocs (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+  bfd *dynobj;
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  bfd_signed_vma *local_got_refcounts;
+  const Elf_Internal_Rela *rel;
+  const Elf_Internal_Rela *rel_end;
+  asection *sgot;
+  asection *srelgot;
+  asection *sreloc;
+
+  if (info->relocateable)
+    return true;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_refcounts = elf_local_got_offsets (abfd);
+
+  sgot = NULL;
+  srelgot = NULL;
+  sreloc = NULL;
+
+  rel_end = relocs + sec->reloc_count;
+  for (rel = relocs; rel < rel_end; rel++)
+    {
+      unsigned long r_symndx;
+      struct elf_link_hash_entry *h;
+
+      r_symndx = ELF64_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 (dynobj == NULL)
+	{
+	  switch (ELF64_R_TYPE (rel->r_info))
+	    {
+	    case R_390_GOT12:
+            case R_390_GOT16:
+	    case R_390_GOT32:
+	    case R_390_GOT64:
+	    case R_390_GOTOFF:
+	    case R_390_GOTPC:
+	    case R_390_GOTPCDBL:
+	    case R_390_GOTENT:
+	      elf_hash_table (info)->dynobj = dynobj = abfd;
+	      if (! _bfd_elf_create_got_section (dynobj, info))
+		return false;
+	      break;
+
+	    default:
+	      break;
+	    }
+	}
+
+
+      switch (ELF64_R_TYPE (rel->r_info))
+	{
+	case R_390_GOT12:
+        case R_390_GOT16:
+	case R_390_GOT32:
+	case R_390_GOT64:
+	case R_390_GOTENT:
+	  /* This symbol requires a global offset table entry.  */
+
+	  if (sgot == NULL)
+	    {
+	      sgot = bfd_get_section_by_name (dynobj, ".got");
+	      BFD_ASSERT (sgot != NULL);
+	    }
+
+
+	  if (srelgot == NULL
+	      && (h != NULL || info->shared))
+	    {
+	      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+	      if (srelgot == NULL)
+		{
+		  srelgot = bfd_make_section (dynobj, ".rela.got");
+		  if (srelgot == NULL
+		      || ! bfd_set_section_flags (dynobj, srelgot,
+						  (SEC_ALLOC
+						   | SEC_LOAD
+						   | SEC_HAS_CONTENTS
+						   | SEC_IN_MEMORY
+						   | SEC_LINKER_CREATED
+						   | SEC_READONLY))
+		      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
+		    return false;
+		}
+	    }
+
+	  if (h != NULL)
+	    {
+	      if (h->got.refcount == -1)
+		{
+		  h->got.refcount = 1;
+
+		  /* Make sure this symbol is output as a dynamic symbol.  */
+		  if (h->dynindx == -1)
+		    {
+		      if (! bfd_elf64_link_record_dynamic_symbol (info, h))
+			return false;
+		    }
+		  
+		  sgot->_raw_size += 8;
+		  srelgot->_raw_size += sizeof (Elf64_External_Rela);
+		}
+	      else
+		h->got.refcount += 1;
+	    }
+	  else
+	    {
+     	      /* This is a global offset table entry for a local symbol.  */
+	      if (local_got_refcounts == NULL)
+		{
+		  size_t size;
+
+		  size = symtab_hdr->sh_info * sizeof (bfd_vma);
+		  local_got_refcounts = (bfd_signed_vma *)
+		                         bfd_alloc (abfd, size);
+		  if (local_got_refcounts == NULL)
+		    return false;
+		  elf_local_got_refcounts (abfd) = local_got_refcounts;
+		  memset (local_got_refcounts, -1, size);
+		}
+	      if (local_got_refcounts[r_symndx] == -1)
+		{
+		  local_got_refcounts[r_symndx] = 1;
+
+		  sgot->_raw_size += 8;
+		  if (info->shared)
+		    {
+		      /* If we are generating a shared object, we need to
+			 output a R_390_RELATIVE reloc so that the dynamic
+			 linker can adjust this GOT entry.  */
+		      srelgot->_raw_size += sizeof (Elf64_External_Rela);
+		    }
+		}
+	      else
+		local_got_refcounts[r_symndx] += 1;
+
+	    }
+	  break;
+
+        case R_390_PLT16DBL:
+	case R_390_PLT32:
+	case R_390_PLT32DBL:
+	case R_390_PLT64:
+	  /* 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->plt.refcount == -1)
+	    {
+	      h->plt.refcount = 1;
+	      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	    }
+	  else
+	    h->plt.refcount += 1;
+	  break;
+
+        case R_390_8:
+        case R_390_16:
+	case R_390_32:
+	case R_390_64:
+        case R_390_PC16:
+        case R_390_PC16DBL:
+	case R_390_PC32:
+	case R_390_PC32DBL:
+	case R_390_PC64:
+	  if (h != NULL)
+	    h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+
+	  /* 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
+             pcrel_relocs_copied field of the hash table entry.  */
+	  if (info->shared
+              && (sec->flags & SEC_ALLOC) != 0
+	      && (ELF64_R_TYPE (rel->r_info) == R_390_8
+		  || ELF64_R_TYPE (rel->r_info) == R_390_16 
+		  || ELF64_R_TYPE (rel->r_info) == R_390_32
+		  || ELF64_R_TYPE (rel->r_info) == R_390_64
+		  || (h != NULL
+		      && h->dynindx != -1
+		      && (! info->symbolic
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0))))
+	    {
+	      /* 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;
+		    }
+		}
+
+	      sreloc->_raw_size += sizeof (Elf64_External_Rela);
+
+	      /* If we are linking with -Bsymbolic, and this is a
+                 global symbol, we count the number of PC relative
+                 relocations we have entered for this symbol, so that
+                 we can discard them again if the symbol is later
+                 defined by a regular object.  Note that this function
+                 is only called if we are using an elf64_s390 linker
+                 hash table, which means that h is really a pointer to
+                 an elf64_s390_link_hash_entry.  */
+	      if (h != NULL
+		  && (ELF64_R_TYPE (rel->r_info) == R_390_PC16 ||
+		      ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL ||
+		      ELF64_R_TYPE (rel->r_info) == R_390_PC32 ||
+		      ELF64_R_TYPE (rel->r_info) == R_390_PC32DBL ||
+		      ELF64_R_TYPE (rel->r_info) == R_390_PC64))
+		{
+		  struct elf_s390_link_hash_entry *eh;
+		  struct elf_s390_pcrel_relocs_copied *p;
+
+		  eh = (struct elf_s390_link_hash_entry *) h;
+
+		  for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
+		    if (p->section == sreloc)
+		      break;
+
+		  if (p == NULL)
+		    {
+		      p = ((struct elf_s390_pcrel_relocs_copied *)
+			   bfd_alloc (dynobj, sizeof *p));
+		      if (p == NULL)
+			return false;
+		      p->next = eh->pcrel_relocs_copied;
+		      eh->pcrel_relocs_copied = p;
+		      p->section = sreloc;
+		      p->count = 0;
+		    }
+
+		  ++p->count;
+		}
+	    }
+
+	  break;
+
+	  /* This relocation describes the C++ object vtable hierarchy.
+	     Reconstruct it for later use during GC.  */
+        case R_390_GNU_VTINHERIT:
+          if (!_bfd_elf64_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_390_GNU_VTENTRY:
+          if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+            return false;
+          break;
+                   
+	default:
+	  break;
+	}
+    }
+
+  return true;
+}
+
+/* Return the section that should be marked against GC for a given
+   relocation.  */
+
+static asection *
+elf_s390_gc_mark_hook (abfd, info, rel, h, sym)
+     bfd *abfd;
+     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 (ELF64_R_TYPE (rel->r_info))
+	{
+	case R_390_GNU_VTINHERIT:
+	case R_390_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
+    {
+      if (!(elf_bad_symtab (abfd)
+	    && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
+	  && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
+		&& sym->st_shndx != SHN_COMMON))
+	{
+	  return bfd_section_from_elf_index (abfd, sym->st_shndx);
+	}
+    }
+
+  return NULL;
+}
+
+/* Update the got entry reference counts for the section being removed.  */
+
+static boolean
+elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+     asection *sec ATTRIBUTE_UNUSED;
+     const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
+{
+  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;
+  bfd *dynobj;
+  asection *sgot;
+  asection *srelgot;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_refcounts = elf_local_got_refcounts (abfd);
+
+  dynobj = elf_hash_table (info)->dynobj;
+  if (dynobj == NULL)
+    return true;
+
+  sgot = bfd_get_section_by_name (dynobj, ".got");
+  srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+
+  relend = relocs + sec->reloc_count;
+  for (rel = relocs; rel < relend; rel++)
+    switch (ELF64_R_TYPE (rel->r_info))
+      {
+      case R_390_GOT12:
+      case R_390_GOT16:
+      case R_390_GOT32:
+      case R_390_GOT64:
+      case R_390_GOTOFF:
+      case R_390_GOTPC:
+      case R_390_GOTPCDBL:
+      case R_390_GOTENT:
+	r_symndx = ELF64_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;
+		if (h->got.refcount == 0)
+		  {
+		    sgot->_raw_size -= 8;
+		    srelgot->_raw_size -= sizeof (Elf64_External_Rela);
+		  }
+	      }
+	  }
+	else if (local_got_refcounts != NULL)
+	  {
+	    if (local_got_refcounts[r_symndx] > 0)
+	      {
+		local_got_refcounts[r_symndx] -= 1;
+		if (local_got_refcounts[r_symndx] == 0)
+		  {
+		    sgot->_raw_size -= 8;
+		    if (info->shared)
+		      srelgot->_raw_size -= sizeof (Elf64_External_Rela);
+		  }
+	      }
+	  }
+	break;
+
+      case R_390_PLT16DBL:
+      case R_390_PLT32:
+      case R_390_PLT32DBL:
+      case R_390_PLT64:
+	r_symndx = ELF64_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;
+
+      default:
+	break;
+      }
+
+  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
+elf_s390_adjust_dynamic_symbol (info, h)
+     struct bfd_link_info *info;
+     struct elf_link_hash_entry *h;
+{
+  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
+     (although we could actually do it here). */
+  if (h->type == STT_FUNC
+      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
+    {
+      if ((! info->shared
+	   && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
+	   && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
+	  || (info->shared && h->plt.refcount <= 0))
+	{
+	  /* This case can occur if we saw a PLT32 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 PC32
+             reloc instead.  */
+	  h->plt.offset = (bfd_vma) -1;
+	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+	  return true;
+	}
+
+      /* Make sure this symbol is output as a dynamic symbol.  */
+      if (h->dynindx == -1)
+	{
+	  if (! bfd_elf64_link_record_dynamic_symbol (info, h))
+	    return false;
+	}
+
+      s = bfd_get_section_by_name (dynobj, ".plt");
+      BFD_ASSERT (s != NULL);
+
+
+      /* The first  entry in .plt is reserved.  */
+      if (s->_raw_size == 0)
+	s->_raw_size = PLT_FIRST_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
+       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 = s->_raw_size;
+      }
+
+      h->plt.offset = s->_raw_size;
+
+      /* 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.  */
+      s = bfd_get_section_by_name (dynobj, ".got.plt");
+      BFD_ASSERT (s != NULL);
+      s->_raw_size += GOT_ENTRY_SIZE;
+
+      /* We also need to make an entry in the .rela.plt section.  */
+      s = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (s != NULL);
+      s->_raw_size += sizeof (Elf64_External_Rela);
+
+      return true;
+    }
+
+  /* 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;
+
+  /* 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.  */
+
+  s = bfd_get_section_by_name (dynobj, ".dynbss");
+  BFD_ASSERT (s != NULL);
+
+  /* We must generate a R_390_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
+     .rel.bss section we are going to use.  */
+  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
+    {
+      asection *srel;
+
+      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
+      BFD_ASSERT (srel != NULL);
+      srel->_raw_size += sizeof (Elf64_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;
+}
+
+/* Set the sizes of the dynamic sections.  */
+
+static boolean
+elf_s390_size_dynamic_sections (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  bfd *dynobj;
+  asection *s;
+  boolean reltext;
+  boolean relocs;
+  boolean plt;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  BFD_ASSERT (dynobj != NULL);
+
+  if (elf_hash_table (info)->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;
+	}
+    }
+  else
+    {
+      /* We may have created entries in the .rela.got section.
+         However, if we are not creating the dynamic sections, we will
+         not actually use these entries.  Reset the size of .rela.got,
+         which will cause it to get stripped from the output file
+         below.  */
+      s = bfd_get_section_by_name (dynobj, ".rela.got");
+      if (s != NULL)
+	s->_raw_size = 0;
+    }
+
+  /* If this is a -Bsymbolic shared link, then we need to discard all
+     PC relative relocs against symbols defined in a regular object.
+     We allocated space for them in the check_relocs routine, but we
+     will not fill them in in the relocate_section routine.  */
+  if (info->shared)
+    elf_s390_link_hash_traverse (elf_s390_hash_table (info),
+			         elf_s390_discard_copies,
+				 (PTR) info);
+
+  /* The check_relocs and adjust_dynamic_symbol entry points have
+     determined the sizes of the various dynamic sections.  Allocate
+     memory for them.  */
+  plt = false;
+  reltext = false;
+  relocs = false;
+  for (s = dynobj->sections; s != NULL; s = s->next)
+    {
+      const char *name;
+      boolean strip;
+
+      if ((s->flags & SEC_LINKER_CREATED) == 0)
+	continue;
+
+      /* It's OK to base decisions on the section name, because none
+	 of the dynobj section names depend upon the input files.  */
+      name = bfd_get_section_name (dynobj, s);
+
+      strip = false;
+
+      if (strcmp (name, ".plt") == 0)
+	{
+	  if (s->_raw_size == 0)
+	    {
+	      /* Strip this section if we don't need it; see the
+                 comment below.  */
+	      strip = true;
+	    }
+	  else
+	    {
+	      /* Remember whether there is a PLT.  */
+	      plt = true;
+	    }
+	}
+      else if (strncmp (name, ".rela", 5) == 0)
+	{
+	  if (s->_raw_size == 0)
+	    {
+	      /* If we don't need this section, strip it from the
+		 output file.  This is to handle .rela.bss and
+		 .rel.plt.  We must create it in
+		 create_dynamic_sections, because it 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.  */
+	      strip = true;
+	    }
+	  else
+	    {
+	      asection *target;
+
+	      /* Remember whether there are any reloc sections other
+                 than .rela.plt.  */
+	      if (strcmp (name, ".rela.plt") != 0)
+		{
+		  const char *outname;
+
+		  relocs = true;
+
+		  /* If this relocation section applies to a read only
+		     section, then we probably need a DT_TEXTREL
+		     entry.  The entries in the .rela.plt section
+		     really apply to the .got section, which we
+		     created ourselves and so know is not readonly.  */
+		  outname = bfd_get_section_name (output_bfd,
+						  s->output_section);
+		  target = bfd_get_section_by_name (output_bfd, outname + 5);
+		  if (target != NULL
+		      && (target->flags & SEC_READONLY) != 0
+		      && (target->flags & SEC_ALLOC) != 0)
+		    reltext = 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 if (strncmp (name, ".got", 4) != 0)
+	{
+	  /* It's not one of our sections, so don't allocate space.  */
+	  continue;
+	}
+
+      if (strip)
+	{
+	  _bfd_strip_section_from_output (info, s);
+	  continue;
+	}
+
+      /* Allocate memory for the section contents.  */
+      s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
+      if (s->contents == NULL && s->_raw_size != 0)
+	return false;
+    }
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      /* Add some entries to the .dynamic section.  We fill in the
+	 values later, in elf_s390_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.  */
+      if (! info->shared)
+	{
+	  if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
+	    return false;
+	}
+
+      if (plt)
+	{
+	  if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0)
+	      || ! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
+	      || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
+	      || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
+	    return false;
+	}
+
+      if (relocs)
+        {
+          if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
+              || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
+              || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
+					    sizeof (Elf64_External_Rela)))
+	    return false;
+         }
+
+      if (reltext)
+	{
+	  if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
+	    return false;
+	  info->flags |= DF_TEXTREL;
+	}
+    }
+
+  return true;
+}
+
+/* This function is called via elf64_s390_link_hash_traverse if we are
+   creating a shared object with -Bsymbolic.  It discards the space
+   allocated to copy PC relative relocs against symbols which are
+   defined in regular objects.  We allocated space for them in the
+   check_relocs routine, but we won't fill them in in the
+   relocate_section routine.  */
+
+/*ARGSUSED*/
+static boolean
+elf_s390_discard_copies (h, inf)
+     struct elf_s390_link_hash_entry *h;
+     PTR inf;
+{
+  struct elf_s390_pcrel_relocs_copied *s;
+  struct bfd_link_info *info = (struct bfd_link_info *) inf;
+
+  /* If a symbol has been forced local or we have found a regular
+     definition for the symbolic link case, then we won't be needing
+     any relocs.  */
+  if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
+      && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
+	  || info->symbolic))
+    {
+      for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
+	s->section->_raw_size -= s->count * sizeof (Elf64_External_Rela);
+    }
+
+  return true;
+}
+/* Relocate a 390 ELF section.  */
+
+static boolean
+elf_s390_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;
+{
+  bfd *dynobj;
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  bfd_vma *local_got_offsets;
+  asection *sgot;
+  asection *splt;
+  asection *sreloc;
+  Elf_Internal_Rela *rel;
+  Elf_Internal_Rela *relend;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (input_bfd);
+  local_got_offsets = elf_local_got_offsets (input_bfd);
+
+  sgot = NULL;
+  splt = NULL;
+  sreloc = NULL;
+  if (dynobj != NULL)
+    {
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      sgot = bfd_get_section_by_name (dynobj, ".got");
+    }
+
+  rel = relocs;
+  relend = relocs + input_section->reloc_count;
+  for (; rel < relend; rel++)
+    {
+      int r_type;
+      reloc_howto_type *howto;
+      unsigned long r_symndx;
+      struct elf_link_hash_entry *h;
+      Elf_Internal_Sym *sym;
+      asection *sec;
+      bfd_vma relocation;
+      bfd_reloc_status_type r;
+
+      r_type = ELF64_R_TYPE (rel->r_info);
+      if (r_type == R_390_GNU_VTINHERIT
+          || r_type == R_390_GNU_VTENTRY)
+        continue;
+      if (r_type < 0 || r_type >= (int) R_390_max)
+	{
+	  bfd_set_error (bfd_error_bad_value);
+	  return false;
+	}
+      howto = elf_howto_table + r_type;
+
+      r_symndx = ELF64_R_SYM (rel->r_info);
+
+      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.  */
+	  if (r_symndx < symtab_hdr->sh_info)
+	    {
+	      sym = local_syms + r_symndx;
+	      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+		{
+		  sec = local_sections[r_symndx];
+		  rel->r_addend += sec->output_offset + sym->st_value;
+		}
+	    }
+
+	  continue;
+	}
+
+      /* This is a final link.  */
+      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);
+	}
+      else
+	{
+	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	  while (h->root.type == bfd_link_hash_indirect
+		 || h->root.type == bfd_link_hash_warning)
+	    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)
+	    {
+	      sec = h->root.u.def.section;
+	      if ((r_type == R_390_GOTPC
+		   || r_type == R_390_GOTPCDBL)
+		  || ((r_type == R_390_PLT16DBL ||
+		       r_type == R_390_PLT32 ||
+		       r_type == R_390_PLT32DBL ||
+		       r_type == R_390_PLT64)
+                      && splt != NULL
+		      && h->plt.offset != (bfd_vma) -1)
+		  || ((r_type == R_390_GOT12 ||
+                       r_type == R_390_GOT16 ||
+		       r_type == R_390_GOT32 ||
+		       r_type == R_390_GOT64 ||
+		       r_type == R_390_GOTENT)
+		      && elf_hash_table (info)->dynamic_sections_created
+		      && (! info->shared
+			  || (! info->symbolic && h->dynindx != -1)
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0))
+		  || (info->shared
+		      && ((! info->symbolic && h->dynindx != -1)
+			  || (h->elf_link_hash_flags
+			      & ELF_LINK_HASH_DEF_REGULAR) == 0)
+		      && ( r_type == R_390_8 ||
+			   r_type == R_390_16 ||
+                           r_type == R_390_32 ||
+			   r_type == R_390_64 ||
+                           r_type == R_390_PC16 ||
+                           r_type == R_390_PC16DBL ||
+			   r_type == R_390_PC32 ||
+			   r_type == R_390_PC32DBL ||
+			   r_type == R_390_PC64)
+                      && ((input_section->flags & SEC_ALLOC) != 0
+                          /* DWARF will emit R_386_32 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))))
+		{
+		  /* In these cases, we don't need the relocation
+                     value.  We check specially because in some
+                     obscure cases sec->output_section will be NULL.  */
+		  relocation = 0;
+		}
+	      else if (sec->output_section == NULL)
+		{
+		  (*_bfd_error_handler)
+		    (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
+		     bfd_get_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);
+	    }
+	  else if (h->root.type == bfd_link_hash_undefweak)
+	    relocation = 0;
+	  else if (info->shared && !info->symbolic
+		   && !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 (r_type)
+	{
+        case R_390_GOT12:
+        case R_390_GOT16:
+        case R_390_GOT32:
+        case R_390_GOT64:
+        case R_390_GOTENT:
+          /* Relocation is to the entry for this symbol in the global
+             offset table.  */
+	  BFD_ASSERT (sgot != NULL);
+
+          if (h != NULL)
+            {
+              bfd_vma off;
+
+              off = h->got.offset;
+              BFD_ASSERT (off != (bfd_vma) -1);
+
+              if (! elf_hash_table (info)->dynamic_sections_created
+                  || (info->shared
+                      && (info->symbolic || h->dynindx == -1)
+                      && (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 2, we use the
+                     least significant bit to record whether we have
+                     initialized it already.
+
+                     When doing a dynamic link, we create a .rel.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_64 (output_bfd, relocation,
+				  sgot->contents + off);
+                      h->got.offset |= 1;
+                    }
+                }
+	      relocation = sgot->output_offset + off;
+            }
+          else
+            {
+              bfd_vma off;
+
+              BFD_ASSERT (local_got_offsets != NULL
+                          && local_got_offsets[r_symndx] != (bfd_vma) -1);
+
+              off = local_got_offsets[r_symndx];
+
+              /* The offset must always be a multiple of 8.  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_64 (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 = ELF64_R_INFO (0, R_390_RELATIVE);
+		      outrel.r_addend = relocation;
+                      bfd_elf64_swap_reloca_out (output_bfd, &outrel,
+                                                (((Elf64_External_Rela *)
+                                                  srelgot->contents)
+                                                 + srelgot->reloc_count));
+                      ++srelgot->reloc_count;
+                    }
+
+                  local_got_offsets[r_symndx] |= 1;
+                }
+
+	      relocation = sgot->output_offset + off;
+            }
+
+	  /*
+	   * For @GOTENT the relocation is against the offset between
+	   * the instruction and the symbols entry in the GOT and not
+	   * between the start of the GOT and the symbols entry. We
+	   * add the vma of the GOT to get the correct value.
+	   */
+	  if (r_type == R_390_GOTENT)
+	    relocation += sgot->output_section->vma;
+
+          break;
+ 
+        case R_390_GOTOFF:
+          /* Relocation is relative to the start of the global offset
+             table.  */
+
+          if (sgot == NULL)
+            {
+              sgot = bfd_get_section_by_name (dynobj, ".got");
+              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;
+
+          break;
+
+        case R_390_GOTPC:
+	case R_390_GOTPCDBL:
+          /* Use global offset table as symbol value.  */
+
+          if (sgot == NULL)
+            {
+              sgot = bfd_get_section_by_name (dynobj, ".got");
+              BFD_ASSERT (sgot != NULL);
+            }
+
+          relocation = sgot->output_section->vma;
+
+          break;
+
+        case R_390_PLT16DBL:
+        case R_390_PLT32:
+        case R_390_PLT32DBL:
+        case R_390_PLT64:
+          /* Relocation is to the entry for this symbol in the
+             procedure linkage table.  */
+
+          /* Resolve a PLT32 reloc against a local symbol directly,
+             without using the procedure linkage table.  */
+          if (h == NULL)
+            break;
+
+          if (h->plt.offset == (bfd_vma) -1 || splt == NULL)
+            {
+              /* We didn't make a PLT entry for this symbol.  This
+                 happens when statically linking PIC code, or when
+                 using -Bsymbolic.  */
+              break;
+            }
+
+          relocation = (splt->output_section->vma
+                        + splt->output_offset
+                        + h->plt.offset);
+
+          break;
+
+        case R_390_8:
+        case R_390_16:
+        case R_390_32:
+        case R_390_64:
+        case R_390_PC16:
+        case R_390_PC16DBL:
+        case R_390_PC32:
+	case R_390_PC32DBL:
+        case R_390_PC64:
+          if (info->shared
+              && (input_section->flags & SEC_ALLOC) != 0
+              && (r_type == R_390_8
+                  || r_type == R_390_16
+		  || r_type == R_390_32
+		  || r_type == R_390_64
+                  || (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;
+
+              if (elf_section_data (input_section)->stab_info == NULL)
+                outrel.r_offset = rel->r_offset;
+              else
+                {
+                  bfd_vma off;
+
+                  off = (_bfd_stab_section_offset
+                         (output_bfd, &elf_hash_table (info)->stab_info,
+                          input_section,
+                          &elf_section_data (input_section)->stab_info,
+                          rel->r_offset));
+                  if (off == (bfd_vma) -1)
+                    skip = true;
+                  outrel.r_offset = off;
+                }
+
+              outrel.r_offset += (input_section->output_section->vma
+                                  + input_section->output_offset);
+
+              if (skip)
+                {
+                  memset (&outrel, 0, sizeof outrel);
+                  relocate = false;
+                }
+              else if (r_type == R_390_PC16 ||
+                       r_type == R_390_PC16DBL ||
+		       r_type == R_390_PC32 || 
+		       r_type == R_390_PC32DBL ||
+		       r_type == R_390_PC64)
+                {
+                  BFD_ASSERT (h != NULL && h->dynindx != -1);
+		  relocate = false;
+                  outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
+		  outrel.r_addend = relocation + rel->r_addend;
+                }
+              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 = ELF64_R_INFO (0, R_390_RELATIVE);
+		      outrel.r_addend = relocation + rel->r_addend;
+                    }
+		  else
+		    {
+		      BFD_ASSERT (h->dynindx != -1);
+		      relocate = false;
+		      outrel.r_info = ELF64_R_INFO (h->dynindx, R_390_64);
+		      outrel.r_addend = relocation + rel->r_addend;
+		    }
+                }
+
+              bfd_elf64_swap_reloca_out (output_bfd, &outrel,
+                                        (((Elf64_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;
+            }
+
+          break;
+
+        default:
+          break;
+        }
+
+      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+				      contents, rel->r_offset,
+				      relocation, rel->r_addend);
+
+      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;
+}
+
+/* Finish up dynamic symbol handling.  We set the contents of various
+   dynamic sections here.  */
+
+static boolean
+elf_s390_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;
+{
+  bfd *dynobj;
+
+  dynobj = elf_hash_table (info)->dynobj;
+
+  if (h->plt.offset != (bfd_vma) -1)
+    {
+      asection *splt;
+      asection *srela;
+      Elf_Internal_Rela rela;
+      bfd_vma got_offset;
+      bfd_vma plt_index;
+      asection *sgot;
+
+      /* This symbol has an entry in the procedure linkage table.  Set
+         it up.  */
+
+      BFD_ASSERT (h->dynindx != -1);
+
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
+      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
+
+      /* Calc. index no. 
+         Current offset - size first entry / entry size.  */
+      plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
+
+      /* Offset in GOT is PLT index plus GOT headers(3) times 8,
+         addr & GOT addr.  */
+      got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
+
+      /* Fill in the blueprint of a PLT.  */
+      bfd_put_32 (output_bfd, PLT_ENTRY_WORD0,
+		  splt->contents + h->plt.offset);
+      bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
+		  splt->contents + h->plt.offset + 4);
+      bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
+		  splt->contents + h->plt.offset + 8);
+      bfd_put_32 (output_bfd, PLT_ENTRY_WORD3,
+		  splt->contents + h->plt.offset + 12);
+      bfd_put_32 (output_bfd, PLT_ENTRY_WORD4,
+		  splt->contents + h->plt.offset + 16);
+      bfd_put_32 (output_bfd, PLT_ENTRY_WORD5,
+		  splt->contents + h->plt.offset + 20);
+      bfd_put_32 (output_bfd, PLT_ENTRY_WORD6,
+		  splt->contents + h->plt.offset + 24);
+      bfd_put_32 (output_bfd, PLT_ENTRY_WORD7,
+		  splt->contents + h->plt.offset + 28);
+      /* Fixup the relative address to the GOT entry */
+      bfd_put_32 (output_bfd,
+		  (sgot->output_section->vma + sgot->output_offset + got_offset
+		   - (splt->output_section->vma + h->plt.offset))/2,
+		  splt->contents + h->plt.offset + 2);
+      /* Fixup the relative branch to PLT 0 */
+      bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
+				 (PLT_ENTRY_SIZE * plt_index) + 22)/2,
+		  splt->contents + h->plt.offset + 24);
+      /* Fixup offset into symbol table */
+      bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
+		  splt->contents + h->plt.offset + 28);
+
+      /* Fill in the entry in the .rela.plt section.  */
+      rela.r_offset = (sgot->output_section->vma
+		       + sgot->output_offset
+		       + got_offset);
+      rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
+      rela.r_addend = 0;
+      bfd_elf64_swap_reloca_out (output_bfd, &rela,
+				 ((Elf64_External_Rela *) srela->contents
+				  + plt_index ));
+
+      /* Fill in the entry in the global offset table.
+         Points to instruction after GOT offset.  */
+      bfd_put_64 (output_bfd,
+		  (splt->output_section->vma
+		   + splt->output_offset
+		   + h->plt.offset
+		   + 14),
+		  sgot->contents + got_offset);
+
+
+      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 *srela;
+      Elf_Internal_Rela rela;
+
+      /* This symbol has an entry in the global offset table.  Set it
+         up.  */
+
+      sgot = bfd_get_section_by_name (dynobj, ".got");
+      srela = bfd_get_section_by_name (dynobj, ".rela.got");
+      BFD_ASSERT (sgot != NULL && srela != NULL);
+
+      rela.r_offset = (sgot->output_section->vma
+		       + sgot->output_offset
+		       + (h->got.offset &~ 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 (! elf_hash_table (info)->dynamic_sections_created
+	  || (info->shared
+	      && (info->symbolic || h->dynindx == -1)
+	      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
+        {
+          rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
+          rela.r_addend = (h->root.u.def.value
+                           + h->root.u.def.section->output_section->vma
+                           + h->root.u.def.section->output_offset);
+        }
+      else
+	{
+	  BFD_ASSERT((h->got.offset & 1) == 0);
+	  bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
+	  rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
+          rela.r_addend = 0;
+        }
+
+      bfd_elf64_swap_reloca_out (output_bfd, &rela,
+				 ((Elf64_External_Rela *) srela->contents
+				  + srela->reloc_count));
+      ++srela->reloc_count;
+    }
+
+  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
+    {
+      asection *s;
+      Elf_Internal_Rela rela;
+
+      /* This symbols 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);
+
+      rela.r_offset = (h->root.u.def.value
+		       + h->root.u.def.section->output_section->vma
+		       + h->root.u.def.section->output_offset);
+      rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
+      rela.r_addend = 0;
+      bfd_elf64_swap_reloca_out (output_bfd, &rela,
+				 ((Elf64_External_Rela *) s->contents
+				  + s->reloc_count));
+      ++s->reloc_count;
+    }
+
+  /* Mark some specially defined symbols as absolute.  */
+  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+      || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
+      || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
+    sym->st_shndx = SHN_ABS;
+
+  return true;
+}
+
+/* Finish up the dynamic sections.  */
+
+static boolean
+elf_s390_finish_dynamic_sections (output_bfd, info)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+{
+  bfd *dynobj;
+  asection *sdyn;
+  asection *sgot;
+
+  dynobj = elf_hash_table (info)->dynobj;
+
+  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
+  BFD_ASSERT (sgot != NULL);
+  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      asection *splt;
+      Elf64_External_Dyn *dyncon, *dynconend;
+
+      BFD_ASSERT (sdyn != NULL);
+
+      dyncon = (Elf64_External_Dyn *) sdyn->contents;
+      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
+      for (; dyncon < dynconend; dyncon++)
+	{
+	  Elf_Internal_Dyn dyn;
+	  const char *name;
+	  asection *s;
+
+	  bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
+
+	  switch (dyn.d_tag)
+	    {
+	    default:
+	      break;
+
+	    case DT_PLTGOT:
+	      name = ".got";
+	      goto get_vma;
+	    case DT_JMPREL:
+	      name = ".rela.plt";
+	    get_vma:
+	      s = bfd_get_section_by_name(output_bfd, name);
+	      BFD_ASSERT (s != NULL);
+	      dyn.d_un.d_ptr = s->vma;
+	      bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
+	      break;
+
+	    case DT_PLTRELSZ:
+	      s = bfd_get_section_by_name (output_bfd, ".rela.plt");
+	      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_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
+	      break;
+
+	    case DT_RELASZ:
+	      /* The procedure linkage table relocs (DT_JMPREL) should
+		 not be included in the overall relocs (DT_RELA).
+		 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.  */
+	      s = bfd_get_section_by_name (output_bfd, ".rela.plt");
+	      if (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_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
+	      break;
+	    }
+	}
+
+      /* Fill in the special first entry in the procedure linkage table.  */
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      if (splt && splt->_raw_size > 0)
+	{
+	  /* fill in blueprint for plt 0 entry */
+	  bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD0,
+		      splt->contents );
+	  bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD1,
+		      splt->contents +4 );
+	  bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD3,
+		      splt->contents +12 );
+	  bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD4,
+		      splt->contents +16 );
+	  bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD5,
+		      splt->contents +20 );
+	  bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD6,
+		      splt->contents + 24);
+	  bfd_put_32 (output_bfd, PLT_FIRST_ENTRY_WORD7,
+		      splt->contents + 28 );
+	  /* Fixup relative address to start of GOT */
+	  bfd_put_32 (output_bfd,
+		      (sgot->output_section->vma + sgot->output_offset
+		       - splt->output_section->vma - 6)/2,
+		      splt->contents + 8);
+	}
+
+      elf_section_data (splt->output_section)->this_hdr.sh_entsize = 
+	PLT_ENTRY_SIZE;
+    }
+
+  /* Set the first entry in the global offset table to the address of
+     the dynamic section.  */
+  if (sgot->_raw_size > 0)
+    {
+      if (sdyn == NULL)
+	bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
+      else
+	bfd_put_64 (output_bfd,
+		    sdyn->output_section->vma + sdyn->output_offset,
+		    sgot->contents);
+
+      /* One entry for shared object struct ptr.  */
+      bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
+      /* One entry for _dl_runtime_resolve.  */
+      bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 12);
+    }
+
+  elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
+
+  return true;
+}
+
+static boolean
+elf_s390_object_p (abfd)
+     bfd *abfd;
+{
+  return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_esame);
+}
+
+/*
+ * Why was the hash table entry size definition changed from
+ * ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
+ * this is the only reason for the s390_elf64_size_info structure.
+ */
+
+const struct elf_size_info s390_elf64_size_info =
+{
+  sizeof (Elf64_External_Ehdr),
+  sizeof (Elf64_External_Phdr),
+  sizeof (Elf64_External_Shdr),
+  sizeof (Elf64_External_Rel),
+  sizeof (Elf64_External_Rela),
+  sizeof (Elf64_External_Sym),
+  sizeof (Elf64_External_Dyn),
+  sizeof (Elf_External_Note),
+  8,            /* hash-table entry size */
+  1,            /* internal relocations per external relocations */
+  64,		/* arch_size */
+  8,		/* file_align */
+  ELFCLASS64, EV_CURRENT,
+  bfd_elf64_write_out_phdrs,
+  bfd_elf64_write_shdrs_and_ehdr,
+  bfd_elf64_write_relocs,
+  bfd_elf64_swap_symbol_out,
+  bfd_elf64_slurp_reloc_table,
+  bfd_elf64_slurp_symbol_table,
+  bfd_elf64_swap_dyn_in,
+  bfd_elf64_swap_dyn_out,
+  NULL,
+  NULL,
+  NULL,
+  NULL
+};
+
+#define TARGET_BIG_SYM	bfd_elf64_s390_vec
+#define TARGET_BIG_NAME	"elf64-s390"
+#define ELF_ARCH	bfd_arch_s390
+#define ELF_MACHINE_CODE EM_S390
+#define ELF_MACHINE_ALT1 EM_S390_OLD
+#define ELF_MAXPAGESIZE 0x1000
+
+#define elf_backend_size_info		s390_elf64_size_info
+
+#define elf_backend_can_gc_sections	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	24
+#define elf_backend_plt_header_size	PLT_ENTRY_SIZE
+
+#define elf_info_to_howto		elf_s390_info_to_howto
+
+#define bfd_elf64_bfd_final_link	      _bfd_elf64_gc_common_final_link
+#define bfd_elf64_bfd_is_local_label_name     elf_s390_is_local_label_name
+#define bfd_elf64_bfd_link_hash_table_create  elf_s390_link_hash_table_create
+#define bfd_elf64_bfd_reloc_type_lookup	      elf_s390_reloc_type_lookup
+
+#define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
+#define elf_backend_check_relocs	      elf_s390_check_relocs
+#define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
+#define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
+#define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
+#define elf_backend_gc_mark_hook	      elf_s390_gc_mark_hook
+#define elf_backend_gc_sweep_hook	      elf_s390_gc_sweep_hook
+#define elf_backend_relocate_section	      elf_s390_relocate_section
+#define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
+
+#define elf_backend_object_p                  elf_s390_object_p
+
+#include "elf64-target.h"
diff --git a/bfd/libbfd.h b/bfd/libbfd.h
index 68f9316..7fee079 100644
--- a/bfd/libbfd.h
+++ b/bfd/libbfd.h
@@ -910,6 +910,23 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@",
   "BFD_RELOC_AVR_HI8_LDI_PM_NEG",
   "BFD_RELOC_AVR_HH8_LDI_PM_NEG",
   "BFD_RELOC_AVR_CALL",
+  "BFD_RELOC_390_12",
+  "BFD_RELOC_390_GOT12",
+  "BFD_RELOC_390_PLT32",
+  "BFD_RELOC_390_COPY",
+  "BFD_RELOC_390_GLOB_DAT",
+  "BFD_RELOC_390_JMP_SLOT",
+  "BFD_RELOC_390_RELATIVE",
+  "BFD_RELOC_390_GOTPC",
+  "BFD_RELOC_390_GOT16",
+  "BFD_RELOC_390_PC16DBL",
+  "BFD_RELOC_390_PLT16DBL",
+  "BFD_RELOC_390_PC32DBL",
+  "BFD_RELOC_390_PLT32DBL",
+  "BFD_RELOC_390_GOTPCDBL",
+  "BFD_RELOC_390_GOT64",
+  "BFD_RELOC_390_PLT64",
+  "BFD_RELOC_390_GOTENT",
   "BFD_RELOC_VTABLE_INHERIT",
   "BFD_RELOC_VTABLE_ENTRY",
   "BFD_RELOC_IA64_IMM14",
diff --git a/bfd/po/POTFILES.in b/bfd/po/POTFILES.in
index f75b4ca..1ac5d8e 100644
--- a/bfd/po/POTFILES.in
+++ b/bfd/po/POTFILES.in
@@ -85,6 +85,7 @@ cpu-ns32k.c
 cpu-pj.c
 cpu-powerpc.c
 cpu-rs6000.c
+cpu-s390.c
 cpu-sh.c
 cpu-sparc.c
 cpu-tic30.c
@@ -127,6 +128,7 @@ elf32-mcore.c
 elf32-mips.c
 elf32-pj.c
 elf32-ppc.c
+elf32-s390.c
 elf32-sh.c
 elf32-sh-lin.c
 elf32-sparc.c
@@ -137,6 +139,7 @@ elf64-gen.c
 elf64-hppa.c
 elf64-hppa.h
 elf64-mips.c
+elf64-s390.c
 elf64-sparc.c
 elf64-x86-64.c
 elfarm-nabi.c
diff --git a/bfd/po/bfd.pot b/bfd/po/bfd.pot
index 40cba07..38af0b5 100644
--- a/bfd/po/bfd.pot
+++ b/bfd/po/bfd.pot
@@ -6,7 +6,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
-"POT-Creation-Date: 2001-02-07 15:02-0800\n"
+"POT-Creation-Date: 2001-02-09 16:27-0800\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"
@@ -191,7 +191,7 @@ msgstr ""
 msgid "GP relative relocation used when GP not defined"
 msgstr ""
 
-#: coff-alpha.c:1486 elf64-alpha.c:4037
+#: coff-alpha.c:1486 elf64-alpha.c:4044
 msgid "using multiple gp values"
 msgstr ""
 
@@ -375,7 +375,7 @@ msgstr ""
 msgid "uncertain calling convention for non-COFF symbol"
 msgstr ""
 
-#: cofflink.c:526 elflink.h:1647
+#: cofflink.c:526 elflink.h:1651
 #, c-format
 msgid "Warning: type of symbol `%s' changed from %d to %d in %s"
 msgstr ""
@@ -549,8 +549,9 @@ msgstr ""
 msgid "%s: Warning: Thumb BLX instruction targets thumb function '%s'."
 msgstr ""
 
-#: elf-hppa.h:1369 elf-hppa.h:1402 elf32-arm.h:1853 elf32-i386.c:1439
-#: elf32-ppc.c:3092 elf32-sh.c:2996 elf64-x86-64.c:1182
+#: elf-hppa.h:1369 elf-hppa.h:1402 elf32-arm.h:1853 elf32-i386.c:1442
+#: elf32-ppc.c:3092 elf32-s390.c:1442 elf32-sh.c:2996 elf64-s390.c:1431
+#: elf64-x86-64.c:1182
 #, c-format
 msgid ""
 "%s: warning: unresolvable relocation against symbol `%s' from %s section"
@@ -799,12 +800,12 @@ msgstr ""
 msgid "%s: invalid relocation type %d"
 msgstr ""
 
-#: elf32-i386.c:678 elf32-i386.c:1646
+#: elf32-i386.c:681 elf32-i386.c:1649
 #, c-format
 msgid "%s(%s): bad relocation section name `%s'"
 msgstr ""
 
-#: elf32-i386.c:683 elf32-i386.c:1651
+#: elf32-i386.c:686 elf32-i386.c:1654
 #, c-format
 msgid "%s: bad relocation section name `%s'"
 msgstr ""
@@ -889,7 +890,7 @@ msgstr ""
 msgid "%s: ABI mismatch: linking %s module with previous %s modules"
 msgstr ""
 
-#: elf32-mips.c:2667 elf32-ppc.c:1477 elf64-sparc.c:2969
+#: elf32-mips.c:2667 elf32-ppc.c:1477 elf64-sparc.c:2991
 #, c-format
 msgid "%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"
 msgstr ""
@@ -970,7 +971,7 @@ msgstr ""
 msgid "static procedure (no name)"
 msgstr ""
 
-#: elf32-mips.c:5005 elf64-alpha.c:4410
+#: elf32-mips.c:5005 elf64-alpha.c:4417
 #, c-format
 msgid "%s: illegal section name `%s'"
 msgstr ""
@@ -1072,7 +1073,7 @@ msgstr ""
 msgid "%s: 0x%lx: fatal: reloc overflow while relaxing"
 msgstr ""
 
-#: elf32-sparc.c:1512 elf64-sparc.c:2260
+#: elf32-sparc.c:1512 elf64-sparc.c:2264
 #, c-format
 msgid "%s: probably compiled without -fPIC?"
 msgstr ""
@@ -1154,11 +1155,11 @@ msgstr ""
 msgid "v850ea architecture"
 msgstr ""
 
-#: elf64-alpha.c:978
+#: elf64-alpha.c:985
 msgid "GPDISP relocation did not find ldah and lda instructions"
 msgstr ""
 
-#: elf64-alpha.c:3047
+#: elf64-alpha.c:3054
 #, c-format
 msgid "%s: .got subsegment exceeds 64K (size %d)"
 msgstr ""
@@ -1168,32 +1169,32 @@ msgstr ""
 msgid "stub entry for %s cannot load .plt, dp offset = %ld"
 msgstr ""
 
-#: elf64-sparc.c:1246
+#: elf64-sparc.c:1249
 #, c-format
 msgid "%s: check_relocs: unhandled reloc type %d"
 msgstr ""
 
-#: elf64-sparc.c:1283
+#: elf64-sparc.c:1286
 msgid "%s: Only registers %%g[2367] can be declared using STT_REGISTER"
 msgstr ""
 
-#: elf64-sparc.c:1303
+#: elf64-sparc.c:1306
 msgid ""
 "Register %%g%d used incompatibly: previously declared in %s to %s, in %s "
 "redefined to %s"
 msgstr ""
 
-#: elf64-sparc.c:1326
+#: elf64-sparc.c:1329
 #, c-format
 msgid "Symbol `%s' has differing types: previously %s, REGISTER in %s"
 msgstr ""
 
-#: elf64-sparc.c:1372
+#: elf64-sparc.c:1375
 #, c-format
 msgid "Symbol `%s' has differing types: REGISTER in %s, %s in %s"
 msgstr ""
 
-#: elf64-sparc.c:2950
+#: elf64-sparc.c:2972
 #, c-format
 msgid "%s: linking UltraSPARC specific with HAL specific code"
 msgstr ""
@@ -1269,24 +1270,24 @@ msgstr ""
 msgid "%s: warning: allocated section `%s' not in segment"
 msgstr ""
 
-#: elf.c:3616
+#: elf.c:3619
 #, c-format
 msgid "%s: symbol `%s' required but not present"
 msgstr ""
 
-#: elf.c:3625
+#: elf.c:3628
 #, c-format
 msgid ""
 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = "
 "0x%.8lx%s\n"
 msgstr ""
 
-#: elf.c:3866
+#: elf.c:3869
 #, c-format
 msgid "%s: warning: Empty loadable segment detected\n"
 msgstr ""
 
-#: elf.c:5213
+#: elf.c:5216
 #, c-format
 msgid "%s: unsupported relocation type %s"
 msgstr ""
@@ -1301,37 +1302,37 @@ msgstr ""
 msgid "%s: Section %s is already to large to put hole of %ld bytes in"
 msgstr ""
 
-#: elflink.h:1464
+#: elflink.h:1468
 #, c-format
 msgid "%s: %s: invalid version %u (max %d)"
 msgstr ""
 
-#: elflink.h:1505
+#: elflink.h:1509
 #, c-format
 msgid "%s: %s: invalid needed version %d"
 msgstr ""
 
-#: elflink.h:1625
+#: elflink.h:1629
 #, c-format
 msgid "Warning: size of symbol `%s' changed from %lu to %lu in %s"
 msgstr ""
 
-#: elflink.h:1871
+#: elflink.h:1875
 #, c-format
 msgid "%s: warning: unexpected redefinition of `%s'"
 msgstr ""
 
-#: elflink.h:3656
+#: elflink.h:3660
 #, c-format
 msgid "warning: type and size of dynamic symbol `%s' are not defined"
 msgstr ""
 
-#: elflink.h:3928
+#: elflink.h:3932
 #, c-format
 msgid "%s: undefined versioned symbol name %s"
 msgstr ""
 
-#: elflink.h:5177
+#: elflink.h:5181
 #, c-format
 msgid "%s: could not find output section %s for input section %s"
 msgstr ""
diff --git a/bfd/reloc.c b/bfd/reloc.c
index f37a6a9..9d45163 100644
--- a/bfd/reloc.c
+++ b/bfd/reloc.c
@@ -2736,6 +2736,75 @@ ENUMDOC
   into 22 bits.
 
 ENUM
+  BFD_RELOC_390_12
+ENUMDOC
+   Direct 12 bit.
+ENUM
+  BFD_RELOC_390_GOT12
+ENUMDOC
+  12 bit GOT offset.
+ENUM
+  BFD_RELOC_390_PLT32
+ENUMDOC
+  32 bit PC relative PLT address.
+ENUM
+  BFD_RELOC_390_COPY
+ENUMDOC
+  Copy symbol at runtime.
+ENUM
+  BFD_RELOC_390_GLOB_DAT
+ENUMDOC
+  Create GOT entry.
+ENUM
+  BFD_RELOC_390_JMP_SLOT
+ENUMDOC
+  Create PLT entry.
+ENUM
+  BFD_RELOC_390_RELATIVE
+ENUMDOC
+  Adjust by program base.
+ENUM
+  BFD_RELOC_390_GOTPC
+ENUMDOC
+  32 bit PC relative offset to GOT.
+ENUM
+  BFD_RELOC_390_GOT16
+ENUMDOC
+  16 bit GOT offset.
+ENUM
+  BFD_RELOC_390_PC16DBL
+ENUMDOC
+  PC relative 16 bit shifted by 1.
+ENUM
+  BFD_RELOC_390_PLT16DBL
+ENUMDOC
+  16 bit PC rel. PLT shifted by 1.
+ENUM
+  BFD_RELOC_390_PC32DBL
+ENUMDOC
+  PC relative 32 bit shifted by 1.
+ENUM
+  BFD_RELOC_390_PLT32DBL
+ENUMDOC
+  32 bit PC rel. PLT shifted by 1.
+ENUM
+  BFD_RELOC_390_GOTPCDBL
+ENUMDOC
+  32 bit PC rel. GOT shifted by 1.
+ENUM
+  BFD_RELOC_390_GOT64
+ENUMDOC
+  64 bit GOT offset.
+ENUM
+  BFD_RELOC_390_PLT64
+ENUMDOC
+  64 bit PC relative PLT address.
+ENUM
+  BFD_RELOC_390_GOTENT
+ENUMDOC
+  32 bit rel. offset to GOT entry.
+                  
+ENUM
   BFD_RELOC_VTABLE_INHERIT
 ENUMX
   BFD_RELOC_VTABLE_ENTRY
diff --git a/bfd/targets.c b/bfd/targets.c
index 0211ec8..70b262d 100644
--- a/bfd/targets.c
+++ b/bfd/targets.c
@@ -542,6 +542,7 @@ extern const bfd_target bfd_elf32_pj_vec;
 extern const bfd_target bfd_elf32_pjl_vec;
 extern const bfd_target bfd_elf32_powerpc_vec;
 extern const bfd_target bfd_elf32_powerpcle_vec;
+extern const bfd_target bfd_elf32_s390_vec;
 extern const bfd_target bfd_elf32_sh_vec;
 extern const bfd_target bfd_elf32_shblin_vec;
 extern const bfd_target bfd_elf32_shl_vec;
@@ -560,6 +561,7 @@ extern const bfd_target bfd_elf64_ia64_big_vec;
 extern const bfd_target bfd_elf64_ia64_little_vec;
 extern const bfd_target bfd_elf64_little_generic_vec;
 extern const bfd_target bfd_elf64_littlemips_vec;
+extern const bfd_target bfd_elf64_s390_vec;
 extern const bfd_target bfd_elf64_sparc_vec;
 extern const bfd_target bfd_elf64_x86_64_vec;
 extern const bfd_target bfd_powerpc_pe_vec;
@@ -925,7 +927,10 @@ static const bfd_target * const _bfd_target_vector[] = {
 	&vms_vax_vec,
 	&we32kcoff_vec,
 	&z8kcoff_vec,
-
+        &bfd_elf32_s390_vec, 
+#ifdef BFD64
+        &bfd_elf64_s390_vec,
+#endif
 #endif /* not SELECT_VECS */
 
 /* Always support S-records, for convenience.  */