X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Felf32-s390.c;h=170b1f9daf3213ed94e85f708a826a64e490f77c;hb=e9e0a58e87c33963dda1800900c0e43b7c0213c0;hp=e8d94afd1c02381f494296bb599b0004bb0a81a1;hpb=69fc87f180bf506aef99809a5d3ae79ff3aee6a4;p=deliverable%2Fbinutils-gdb.git

diff --git a/bfd/elf32-s390.c b/bfd/elf32-s390.c
index e8d94afd1c..170b1f9daf 100644
--- a/bfd/elf32-s390.c
+++ b/bfd/elf32-s390.c
@@ -1,12 +1,13 @@
 /* IBM S/390-specific support for 32-bit ELF
-   Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+   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
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -16,11 +17,11 @@
 
    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.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
-#include "bfd.h"
 #include "sysdep.h"
+#include "bfd.h"
 #include "bfdlink.h"
 #include "libbfd.h"
 #include "elf-bfd.h"
@@ -40,17 +41,11 @@ static bfd_boolean create_got_section
 static bfd_boolean elf_s390_create_dynamic_sections
   PARAMS((bfd *, struct bfd_link_info *));
 static void elf_s390_copy_indirect_symbol
-  PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
+  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *,
 	   struct elf_link_hash_entry *));
 static bfd_boolean elf_s390_check_relocs
   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 	   const Elf_Internal_Rela *));
-static asection *elf_s390_gc_mark_hook
-  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
-	   struct elf_link_hash_entry *, Elf_Internal_Sym *));
-static bfd_boolean elf_s390_gc_sweep_hook
-  PARAMS ((bfd *, struct bfd_link_info *, asection *,
-	   const Elf_Internal_Rela *));
 struct elf_s390_link_hash_entry;
 static void elf_s390_adjust_gotplt
   PARAMS ((struct elf_s390_link_hash_entry *));
@@ -72,8 +67,6 @@ static enum elf_reloc_type_class elf_s390_reloc_type_class
   PARAMS ((const Elf_Internal_Rela *));
 static bfd_boolean elf_s390_finish_dynamic_sections
   PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_s390_mkobject
-  PARAMS ((bfd *));
 static bfd_boolean elf_s390_object_p
   PARAMS ((bfd *));
 static bfd_boolean elf_s390_grok_prstatus
@@ -88,6 +81,8 @@ static bfd_vma tpoff
   PARAMS ((struct bfd_link_info *, bfd_vma));
 static void invalid_tls_insn
   PARAMS ((bfd *, asection *, Elf_Internal_Rela *));
+static bfd_reloc_status_type s390_elf_ldisp_reloc
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
 #include "elf/s390.h"
 
@@ -119,7 +114,7 @@ static reloc_howto_type elf_howto_table[] =
 	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,
+  HOWTO(R_390_GOT12,	 0, 1, 12, FALSE, 0, complain_overflow_bitfield,
 	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),
@@ -208,6 +203,14 @@ static reloc_howto_type elf_howto_table[] =
 	bfd_elf_generic_reloc, "R_390_TLS_DTPOFF", FALSE, 0, 0xffffffff, FALSE),
   HOWTO(R_390_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 	bfd_elf_generic_reloc, "R_390_TLS_TPOFF", FALSE, 0, 0xffffffff, FALSE),
+  HOWTO(R_390_20,        0, 2, 20, FALSE, 8, complain_overflow_dont,
+	s390_elf_ldisp_reloc, "R_390_20",      FALSE, 0,0x0fffff00, FALSE),
+  HOWTO(R_390_GOT20,	 0, 2, 20, FALSE, 8, complain_overflow_dont,
+	s390_elf_ldisp_reloc, "R_390_GOT20",   FALSE, 0,0x0fffff00, FALSE),
+  HOWTO(R_390_GOTPLT20,  0, 2, 20, FALSE, 8, complain_overflow_dont,
+	s390_elf_ldisp_reloc, "R_390_GOTPLT20", FALSE, 0,0x0fffff00, FALSE),
+  HOWTO(R_390_TLS_GOTIE20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
+	s390_elf_ldisp_reloc, "R_390_TLS_GOTIE20", FALSE, 0,0x0fffff00, FALSE),
 };
 
 /* GNU extension to record C++ vtable hierarchy.  */
@@ -313,6 +316,14 @@ elf_s390_reloc_type_lookup (abfd, code)
       return &elf_howto_table[(int) R_390_TLS_DTPOFF];
     case BFD_RELOC_390_TLS_TPOFF:
       return &elf_howto_table[(int) R_390_TLS_TPOFF];
+    case BFD_RELOC_390_20:
+      return &elf_howto_table[(int) R_390_20];
+    case BFD_RELOC_390_GOT20:
+      return &elf_howto_table[(int) R_390_GOT20];
+    case BFD_RELOC_390_GOTPLT20:
+      return &elf_howto_table[(int) R_390_GOTPLT20];
+    case BFD_RELOC_390_TLS_GOTIE20:
+      return &elf_howto_table[(int) R_390_TLS_GOTIE20];
     case BFD_RELOC_VTABLE_INHERIT:
       return &elf32_s390_vtinherit_howto;
     case BFD_RELOC_VTABLE_ENTRY:
@@ -323,6 +334,25 @@ elf_s390_reloc_type_lookup (abfd, code)
   return 0;
 }
 
+static reloc_howto_type *
+elf_s390_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+			    const char *r_name)
+{
+  unsigned int i;
+
+  for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
+    if (elf_howto_table[i].name != NULL
+	&& strcasecmp (elf_howto_table[i].name, r_name) == 0)
+      return &elf_howto_table[i];
+
+  if (strcasecmp (elf32_s390_vtinherit_howto.name, r_name) == 0)
+    return &elf32_s390_vtinherit_howto;
+  if (strcasecmp (elf32_s390_vtentry_howto.name, r_name) == 0)
+    return &elf32_s390_vtentry_howto;
+
+  return NULL;
+}
+
 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
    and elf32-s390.c has its own copy.  */
 
@@ -332,7 +362,8 @@ elf_s390_info_to_howto (abfd, cache_ptr, dst)
      arelent *cache_ptr;
      Elf_Internal_Rela *dst;
 {
-  switch (ELF32_R_TYPE(dst->r_info))
+  unsigned int r_type = ELF32_R_TYPE(dst->r_info);
+  switch (r_type)
     {
     case R_390_GNU_VTINHERIT:
       cache_ptr->howto = &elf32_s390_vtinherit_howto;
@@ -343,15 +374,20 @@ elf_s390_info_to_howto (abfd, cache_ptr, dst)
       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)];
+      if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
+	{
+	  (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
+				 abfd, (int) r_type);
+	  r_type = R_390_NONE;
+	}
+      cache_ptr->howto = &elf_howto_table[r_type];
     }
 }
 
 /* A relocation function which doesn't do anything.  */
 static bfd_reloc_status_type
 s390_tls_reloc (abfd, reloc_entry, symbol, data, input_section,
-                      output_bfd, error_message)
+		output_bfd, error_message)
      bfd *abfd ATTRIBUTE_UNUSED;
      arelent *reloc_entry;
      asymbol *symbol ATTRIBUTE_UNUSED;
@@ -365,6 +401,59 @@ s390_tls_reloc (abfd, reloc_entry, symbol, data, input_section,
   return bfd_reloc_ok;
 }
 
+/* Handle the large displacement relocs.  */
+static bfd_reloc_status_type
+s390_elf_ldisp_reloc (abfd, reloc_entry, symbol, data, input_section,
+                      output_bfd, error_message)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     arelent *reloc_entry;
+     asymbol *symbol;
+     PTR data ATTRIBUTE_UNUSED;
+     asection *input_section;
+     bfd *output_bfd;
+     char **error_message ATTRIBUTE_UNUSED;
+{
+  reloc_howto_type *howto = reloc_entry->howto;
+  bfd_vma relocation;
+  bfd_vma insn;
+  
+  if (output_bfd != (bfd *) NULL
+      && (symbol->flags & BSF_SECTION_SYM) == 0
+      && (! howto->partial_inplace
+	  || reloc_entry->addend == 0))
+    {
+      reloc_entry->address += input_section->output_offset;
+      return bfd_reloc_ok;
+    }
+  
+  if (output_bfd != NULL)
+    return bfd_reloc_continue;
+  
+  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
+    return bfd_reloc_outofrange;
+  
+  relocation = (symbol->value
+		+ symbol->section->output_section->vma
+		+ symbol->section->output_offset);
+  relocation += reloc_entry->addend;
+  if (howto->pc_relative)
+    {
+      relocation -= (input_section->output_section->vma
+		     + input_section->output_offset);
+      relocation -= reloc_entry->address;
+    }
+  
+  insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
+  insn |= (relocation & 0xfff) << 16 | (relocation & 0xff000) >> 4;
+  bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
+  
+  if ((bfd_signed_vma) relocation < - 0x80000
+      || (bfd_signed_vma) relocation > 0x7ffff)
+    return bfd_reloc_overflow;
+  else
+    return bfd_reloc_ok;
+}
+
 static bfd_boolean
 elf_s390_is_local_label_name (abfd, name)
      bfd *abfd;
@@ -383,6 +472,12 @@ elf_s390_is_local_label_name (abfd, name)
 
 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 
+/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
+   copying dynamic variables from a shared lib into an app's dynbss
+   section, and instead use a dynamic relocation to point into the
+   shared lib.  */
+#define ELIMINATE_COPY_RELOCS 1
+
 /* 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.  */
@@ -407,7 +502,7 @@ elf_s390_is_local_label_name (abfd, name)
    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:
+   The code for position independent PLT entries looks like this:
 
    r12 holds addr of the current GOT at entry to the PLT
 
@@ -579,11 +674,13 @@ struct elf_s390_link_hash_entry
 #define elf_s390_hash_entry(ent) \
   ((struct elf_s390_link_hash_entry *)(ent))
 
+/* NOTE: Keep this structure in sync with
+   the one declared in elf64-s390.c.  */
 struct elf_s390_obj_tdata
 {
   struct elf_obj_tdata root;
 
-  /* tls_type for each local got entry.  */
+  /* TLS type for each local got entry.  */
   char *local_got_tls_type;
 };
 
@@ -593,29 +690,22 @@ struct elf_s390_obj_tdata
 #define elf_s390_local_got_tls_type(abfd) \
   (elf_s390_tdata (abfd)->local_got_tls_type)
 
+#define is_s390_elf(bfd) \
+  (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
+   && elf_tdata (bfd) != NULL \
+   && elf_object_id (bfd) == S390_ELF_TDATA)
+
 static bfd_boolean
-elf_s390_mkobject (abfd)
-     bfd *abfd;
+elf_s390_mkobject (bfd *abfd)
 {
-  bfd_size_type amt = sizeof (struct elf_s390_obj_tdata);
-  abfd->tdata.any = bfd_zalloc (abfd, amt);
-  if (abfd->tdata.any == NULL)
-    return FALSE;
-  return TRUE;
+  return bfd_elf_allocate_object (abfd, sizeof (struct elf_s390_obj_tdata),
+				  S390_ELF_TDATA);
 }
 
 static bfd_boolean
 elf_s390_object_p (abfd)
      bfd *abfd;
 {
-  /* Allocate our special target data.  */
-  struct elf_s390_obj_tdata *new_tdata;
-  bfd_size_type amt = sizeof (struct elf_s390_obj_tdata);
-  new_tdata = bfd_zalloc (abfd, amt);
-  if (new_tdata == NULL)
-    return FALSE;
-  new_tdata->root = *abfd->tdata.elf_obj_data;
-  abfd->tdata.any = new_tdata;
   /* Set the right machine number for an s390 elf32 file.  */
   return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_31);
 }
@@ -640,8 +730,8 @@ struct elf_s390_link_hash_table
     bfd_vma offset;
   } tls_ldm_got;
 
-  /* Small local sym to section mapping cache.  */
-  struct sym_sec_cache sym_sec;
+  /* Small local sym cache.  */
+  struct sym_cache sym_cache;
 };
 
 /* Get the s390 ELF linker hash table from a link_info structure.  */
@@ -695,7 +785,8 @@ elf_s390_link_hash_table_create (abfd)
   if (ret == NULL)
     return NULL;
 
-  if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
+  if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
+				      sizeof (struct elf_s390_link_hash_entry)))
     {
       free (ret);
       return NULL;
@@ -709,7 +800,7 @@ elf_s390_link_hash_table_create (abfd)
   ret->sdynbss = NULL;
   ret->srelbss = NULL;
   ret->tls_ldm_got.refcount = 0;
-  ret->sym_sec.abfd = NULL;
+  ret->sym_cache.abfd = NULL;
 
   return &ret->elf.root;
 }
@@ -730,17 +821,10 @@ create_got_section (dynobj, info)
   htab = elf_s390_hash_table (info);
   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
-  if (!htab->sgot || !htab->sgotplt)
+  htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+  if (!htab->sgot || !htab->sgotplt || !htab->srelgot)
     abort ();
 
-  htab->srelgot = bfd_make_section (dynobj, ".rela.got");
-  if (htab->srelgot == NULL
-      || ! bfd_set_section_flags (dynobj, htab->srelgot,
-				  (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
-				   | SEC_IN_MEMORY | SEC_LINKER_CREATED
-				   | SEC_READONLY))
-      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
-    return FALSE;
   return TRUE;
 }
 
@@ -778,8 +862,8 @@ elf_s390_create_dynamic_sections (dynobj, info)
 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 
 static void
-elf_s390_copy_indirect_symbol (bed, dir, ind)
-     struct elf_backend_data *bed;
+elf_s390_copy_indirect_symbol (info, dir, ind)
+     struct bfd_link_info *info;
      struct elf_link_hash_entry *dir, *ind;
 {
   struct elf_s390_link_hash_entry *edir, *eind;
@@ -794,10 +878,7 @@ elf_s390_copy_indirect_symbol (bed, dir, ind)
 	  struct elf_s390_dyn_relocs **pp;
 	  struct elf_s390_dyn_relocs *p;
 
-	  if (ind->root.type == bfd_link_hash_indirect)
-	    abort ();
-
-	  /* Add reloc counts against the weak sym to the strong sym
+	  /* Add reloc counts against the indirect sym to the direct sym
 	     list.  Merge any entries against the same section.  */
 	  for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 	    {
@@ -828,7 +909,20 @@ elf_s390_copy_indirect_symbol (bed, dir, ind)
       eind->tls_type = GOT_UNKNOWN;
     }
 
-  _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
+  if (ELIMINATE_COPY_RELOCS
+      && ind->root.type != bfd_link_hash_indirect
+      && dir->dynamic_adjusted)
+    {
+      /* If called to transfer flags for a weakdef during processing
+	 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
+	 We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
+      dir->ref_dynamic |= ind->ref_dynamic;
+      dir->ref_regular |= ind->ref_regular;
+      dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
+      dir->needs_plt |= ind->needs_plt;
+    }
+  else
+    _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 }
 
 static int
@@ -878,11 +972,13 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
   bfd_signed_vma *local_got_refcounts;
   int tls_type, old_tls_type;
 
-  if (info->relocateable)
+  if (info->relocatable)
     return TRUE;
 
+  BFD_ASSERT (is_s390_elf (abfd));
+
   htab = elf_s390_hash_table (info);
-  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  symtab_hdr = &elf_symtab_hdr (abfd);
   sym_hashes = elf_sym_hashes (abfd);
   local_got_refcounts = elf_local_got_refcounts (abfd);
 
@@ -899,16 +995,20 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 
       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 	{
-	  (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
-				 bfd_archive_filename (abfd),
-				 r_symndx);
+	  (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
+				 abfd, r_symndx);
 	  return FALSE;
 	}
 
       if (r_symndx < symtab_hdr->sh_info)
 	h = NULL;
       else
-	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	{
+	  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;
+	}
 
       /* Create got section and local_got_refcounts array if they
 	 are needed.  */
@@ -919,14 +1019,17 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 	{
 	case R_390_GOT12:
 	case R_390_GOT16:
+	case R_390_GOT20:
 	case R_390_GOT32:
 	case R_390_GOTENT:
 	case R_390_GOTPLT12:
 	case R_390_GOTPLT16:
+	case R_390_GOTPLT20:
 	case R_390_GOTPLT32:
 	case R_390_GOTPLTENT:
 	case R_390_TLS_GD32:
 	case R_390_TLS_GOTIE12:
+	case R_390_TLS_GOTIE20:
 	case R_390_TLS_GOTIE32:
 	case R_390_TLS_IEENT:
 	case R_390_TLS_IE32:
@@ -935,7 +1038,7 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 	      && local_got_refcounts == NULL)
 	    {
 	      bfd_size_type size;
-	      
+
 	      size = symtab_hdr->sh_info;
 	      size *= (sizeof (bfd_signed_vma) + sizeof(char));
 	      local_got_refcounts = ((bfd_signed_vma *)
@@ -969,29 +1072,30 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 	  /* Got is created, nothing to be done.  */
 	  break;
 
-        case R_390_PLT16DBL:
-        case R_390_PLT32DBL:
+	case R_390_PLT16DBL:
+	case R_390_PLT32DBL:
 	case R_390_PLT32:
 	case R_390_PLTOFF16:
 	case R_390_PLTOFF32:
 	  /* 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.  */
+	     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.  */
+	     creating a procedure linkage table entry.  */
 	  if (h != NULL)
 	    {
-	      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	      h->needs_plt = 1;
 	      h->plt.refcount += 1;
 	    }
 	  break;
 
 	case R_390_GOTPLT12:
 	case R_390_GOTPLT16:
+	case R_390_GOTPLT20:
 	case R_390_GOTPLT32:
 	case R_390_GOTPLTENT:
 	  /* This symbol requires either a procedure linkage table entry
@@ -1005,7 +1109,7 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 	  if (h != NULL)
 	    {
 	      ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
-	      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+	      h->needs_plt = 1;
 	      h->plt.refcount += 1;
 	    }
 	  else
@@ -1018,14 +1122,16 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 
 	case R_390_TLS_IE32:
 	case R_390_TLS_GOTIE12:
+	case R_390_TLS_GOTIE20:
 	case R_390_TLS_GOTIE32:
 	case R_390_TLS_IEENT:
 	  if (info->shared)
 	    info->flags |= DF_STATIC_TLS;
-	  /* Fall through */
+	  /* Fall through.  */
 
 	case R_390_GOT12:
-        case R_390_GOT16:
+	case R_390_GOT16:
+	case R_390_GOT20:
 	case R_390_GOT32:
 	case R_390_GOTENT:
 	case R_390_TLS_GD32:
@@ -1035,6 +1141,7 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 	    default:
 	    case R_390_GOT12:
 	    case R_390_GOT16:
+	    case R_390_GOT20:
 	    case R_390_GOT32:
 	    case R_390_GOTENT:
 	      tls_type = GOT_NORMAL;
@@ -1047,6 +1154,7 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 	      tls_type = GOT_TLS_IE;
 	      break;
 	    case R_390_TLS_GOTIE12:
+	    case R_390_TLS_GOTIE20:
 	    case R_390_TLS_IEENT:
 	      tls_type = GOT_TLS_IE_NLT;
 	      break;
@@ -1069,8 +1177,8 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 	      if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
 		{
 		  (*_bfd_error_handler)
-		    (_("%s: `%s' accessed both as normal and thread local symbol"),
-		     bfd_archive_filename (abfd), h->root.root.string);
+		    (_("%B: `%s' accessed both as normal and thread local symbol"),
+		     abfd, h->root.root.string);
 		  return FALSE;
 		}
 	      if (old_tls_type > tls_type)
@@ -1087,19 +1195,19 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 
 	  if (r_type != R_390_TLS_IE32)
 	    break;
-	  /* Fall through */
+	  /* Fall through.  */
 
 	case R_390_TLS_LE32:
 	  if (!info->shared)
 	    break;
 	  info->flags |= DF_STATIC_TLS;
-	  /* Fall through */	    
+	  /* Fall through.  */
 
-        case R_390_8:
-        case R_390_16:
+	case R_390_8:
+	case R_390_16:
 	case R_390_32:
-        case R_390_PC16:
-        case R_390_PC16DBL:
+	case R_390_PC16:
+	case R_390_PC16DBL:
 	case R_390_PC32DBL:
 	case R_390_PC32:
 	  if (h != NULL && !info->shared)
@@ -1110,7 +1218,7 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 		 sections have not yet been mapped to output sections.
 		 Tentatively set the flag for now, and correct in
 		 adjust_dynamic_symbol.  */
-	      h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+	      h->non_got_ref = 1;
 
 	      /* We may need a .plt entry if the function this reloc
 		 refers to is in a shared lib.  */
@@ -1145,16 +1253,15 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 		    && ELF32_R_TYPE (rel->r_info) != R_390_PC32DBL
 		    && ELF32_R_TYPE (rel->r_info) != R_390_PC32)
 		   || (h != NULL
-		       && (! info->symbolic
+		       && (! SYMBOLIC_BIND (info, h)
 			   || h->root.type == bfd_link_hash_defweak
-			   || (h->elf_link_hash_flags
-			       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
-	      || (!info->shared
+			   || !h->def_regular))))
+	      || (ELIMINATE_COPY_RELOCS
+		  && !info->shared
 		  && (sec->flags & SEC_ALLOC) != 0
 		  && h != NULL
 		  && (h->root.type == bfd_link_hash_defweak
-		      || (h->elf_link_hash_flags
-			  & ELF_LINK_HASH_DEF_REGULAR) == 0)))
+		      || !h->def_regular)))
 	    {
 	      struct elf_s390_dyn_relocs *p;
 	      struct elf_s390_dyn_relocs **head;
@@ -1164,45 +1271,14 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 		 this reloc.  */
 	      if (sreloc == NULL)
 		{
-		  const char *name;
-		  bfd *dynobj;
-
-		  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;
-
-		  if (strncmp (name, ".rela", 5) != 0
-		      || strcmp (bfd_get_section_name (abfd, sec),
-				 name + 5) != 0)
-		    {
-		      (*_bfd_error_handler)
-			(_("%s: bad relocation section name `%s\'"),
-			 bfd_archive_filename (abfd), name);
-		    }
-
 		  if (htab->elf.dynobj == NULL)
 		    htab->elf.dynobj = abfd;
 
-		  dynobj = htab->elf.dynobj;
-		  sreloc = bfd_get_section_by_name (dynobj, name);
+		  sreloc = _bfd_elf_make_dynamic_reloc_section
+		    (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
+
 		  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;
-		    }
-		  elf_section_data (sec)->sreloc = sreloc;
+		    return FALSE;
 		}
 
 	      /* If this is a global symbol, we count the number of
@@ -1216,21 +1292,28 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 		  /* Track dynamic relocs needed for local syms too.
 		     We really need local syms available to do this
 		     easily.  Oh well.  */
-
 		  asection *s;
-		  s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
-						 sec, r_symndx);
-		  if (s == NULL)
+		  void *vpp;
+		  Elf_Internal_Sym *isym;
+
+		  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+						abfd, r_symndx);
+		  if (isym == NULL)
 		    return FALSE;
 
-		  head = ((struct elf_s390_dyn_relocs **)
-			  &elf_section_data (s)->local_dynrel);
+		  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
+		  if (s == NULL)
+		    s = sec;
+
+		  vpp = &elf_section_data (s)->local_dynrel;
+		  head = (struct elf_s390_dyn_relocs **) vpp;
 		}
 
 	      p = *head;
 	      if (p == NULL || p->sec != sec)
 		{
 		  bfd_size_type amt = sizeof *p;
+
 		  p = ((struct elf_s390_dyn_relocs *)
 		       bfd_alloc (htab->elf.dynobj, amt));
 		  if (p == NULL)
@@ -1253,17 +1336,19 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
 
 	  /* 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;
+	case R_390_GNU_VTINHERIT:
+	  if (!bfd_elf_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;
+	case R_390_GNU_VTENTRY:
+	  BFD_ASSERT (h != NULL);
+	  if (h != NULL
+	      && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+	    return FALSE;
+	  break;
 
 	default:
 	  break;
@@ -1277,78 +1362,76 @@ elf_s390_check_relocs (abfd, info, sec, relocs)
    relocation.  */
 
 static asection *
-elf_s390_gc_mark_hook (sec, info, rel, h, sym)
-     asection *sec;
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     Elf_Internal_Rela *rel;
-     struct elf_link_hash_entry *h;
-     Elf_Internal_Sym *sym;
+elf_s390_gc_mark_hook (asection *sec,
+		       struct bfd_link_info *info,
+		       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;
+    switch (ELF32_R_TYPE (rel->r_info))
+      {
+      case R_390_GNU_VTINHERIT:
+      case R_390_GNU_VTENTRY:
+	return NULL;
+      }
+  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
 
-	default:
-	  switch (h->root.type)
-	    {
-	    case bfd_link_hash_defined:
-	    case bfd_link_hash_defweak:
-	      return h->root.u.def.section;
-
-	    case bfd_link_hash_common:
-	      return h->root.u.c.p->section;
-
-	    default:
-	      break;
-	    }
-	}
-    }
-  else
-    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
-
-  return NULL;
 }
 
 /* Update the got entry reference counts for the section being removed.  */
 
 static bfd_boolean
-elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
-     bfd *abfd;
-     struct bfd_link_info *info;
-     asection *sec;
-     const Elf_Internal_Rela *relocs;
+elf_s390_gc_sweep_hook (bfd *abfd,
+			struct bfd_link_info *info,
+			asection *sec,
+			const Elf_Internal_Rela *relocs)
 {
   Elf_Internal_Shdr *symtab_hdr;
   struct elf_link_hash_entry **sym_hashes;
   bfd_signed_vma *local_got_refcounts;
   const Elf_Internal_Rela *rel, *relend;
-  unsigned long r_symndx;
-  int r_type;
-  struct elf_link_hash_entry *h;
+
+  if (info->relocatable)
+    return TRUE;
 
   elf_section_data (sec)->local_dynrel = NULL;
 
-  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  symtab_hdr = &elf_symtab_hdr (abfd);
   sym_hashes = elf_sym_hashes (abfd);
   local_got_refcounts = elf_local_got_refcounts (abfd);
 
   relend = relocs + sec->reloc_count;
   for (rel = relocs; rel < relend; rel++)
     {
+      unsigned long r_symndx;
+      unsigned int r_type;
+      struct elf_link_hash_entry *h = NULL;
+
       r_symndx = ELF32_R_SYM (rel->r_info);
+      if (r_symndx >= symtab_hdr->sh_info)
+	{
+	  struct elf_s390_link_hash_entry *eh;
+	  struct elf_s390_dyn_relocs **pp;
+	  struct elf_s390_dyn_relocs *p;
 
-      if (r_symndx < symtab_hdr->sh_info)
-	h = NULL;
-      else
-	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+	  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;
+	  eh = (struct elf_s390_link_hash_entry *) h;
 
-      r_type = elf_s390_tls_transition (info,
-					ELF32_R_TYPE (rel->r_info),
-					r_symndx >= symtab_hdr->sh_info);
+	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
+	    if (p->sec == sec)
+	      {
+		/* Everything must go for SEC.  */
+		*pp = p->next;
+		break;
+	      }
+	}
+
+      r_type = ELF32_R_TYPE (rel->r_info);
+      r_type = elf_s390_tls_transition (info, r_type, h != NULL);
       switch (r_type)
 	{
 	case R_390_TLS_LDM32:
@@ -1359,10 +1442,12 @@ elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
 	case R_390_TLS_GD32:
 	case R_390_TLS_IE32:
 	case R_390_TLS_GOTIE12:
+	case R_390_TLS_GOTIE20:
 	case R_390_TLS_GOTIE32:
 	case R_390_TLS_IEENT:
 	case R_390_GOT12:
 	case R_390_GOT16:
+	case R_390_GOT20:
 	case R_390_GOT32:
 	case R_390_GOTOFF16:
 	case R_390_GOTOFF32:
@@ -1379,50 +1464,21 @@ elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
 	      if (local_got_refcounts[r_symndx] > 0)
 		local_got_refcounts[r_symndx] -= 1;
 	    }
-	  if (r_type != R_390_TLS_IE32)
-	    break;
-	  /* Fall through */
-	  
-	case R_390_TLS_LE32:
-	  if (!info->shared)
-	    break;
-	  /* Fall through */
+	  break;
 
 	case R_390_8:
 	case R_390_12:
 	case R_390_16:
+	case R_390_20:
 	case R_390_32:
 	case R_390_PC16:
 	case R_390_PC16DBL:
 	case R_390_PC32DBL:
 	case R_390_PC32:
-	  if (h != NULL)
-	    {
-	      struct elf_s390_link_hash_entry *eh;
-	      struct elf_s390_dyn_relocs **pp;
-	      struct elf_s390_dyn_relocs *p;
-	      
-	      if (!info->shared && h->plt.refcount > 0)
-		h->plt.refcount -= 1;
-	      
-	      eh = (struct elf_s390_link_hash_entry *) h;
-	      
-	      for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
-		if (p->sec == sec)
-		  {
-		    if (ELF32_R_TYPE (rel->r_info) == R_390_PC16
-			|| ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL
-			|| ELF32_R_TYPE (rel->r_info) == R_390_PC32DBL
-			|| ELF32_R_TYPE (rel->r_info) == R_390_PC32)
-		      p->pc_count -= 1;
-		    p->count -= 1;
-		    if (p->count == 0)
-		      *pp = p->next;
-		    break;
-		  }
-	    }
-	  break;
-	  
+	  if (info->shared)
+	    break;
+	  /* Fall through.  */
+
 	case R_390_PLT16DBL:
 	case R_390_PLT32DBL:
 	case R_390_PLT32:
@@ -1437,6 +1493,7 @@ elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
 
 	case R_390_GOTPLT12:
 	case R_390_GOTPLT16:
+	case R_390_GOTPLT20:
 	case R_390_GOTPLT32:
 	case R_390_GOTPLTENT:
 	  if (h != NULL)
@@ -1497,31 +1554,26 @@ elf_s390_adjust_dynamic_symbol (info, h)
      struct elf_link_hash_entry *h;
 {
   struct elf_s390_link_hash_table *htab;
-  struct elf_s390_link_hash_entry * eh;
-  struct elf_s390_dyn_relocs *p;
   asection *s;
-  unsigned int power_of_two;
 
   /* 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)
+      || h->needs_plt)
     {
       if (h->plt.refcount <= 0
-	  || (! info->shared
-	      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
-	      && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
-	      && h->root.type != bfd_link_hash_undefweak
-	      && h->root.type != bfd_link_hash_undefined))
+	  || SYMBOL_CALLS_LOCAL (info, h)
+	  || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
+	      && h->root.type != bfd_link_hash_undefweak))
 	{
 	  /* 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
+	     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;
+	  h->needs_plt = 0;
 	  elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
 	}
 
@@ -1538,12 +1590,14 @@ elf_s390_adjust_dynamic_symbol (info, h)
   /* 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)
+  if (h->u.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;
+      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
+		  || h->u.weakdef->root.type == bfd_link_hash_defweak);
+      h->root.u.def.section = h->u.weakdef->root.u.def.section;
+      h->root.u.def.value = h->u.weakdef->root.u.def.value;
+      if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
+	h->non_got_ref = h->u.weakdef->non_got_ref;
       return TRUE;
     }
 
@@ -1559,29 +1613,42 @@ elf_s390_adjust_dynamic_symbol (info, h)
 
   /* 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)
+  if (!h->non_got_ref)
     return TRUE;
 
   /* If -z nocopyreloc was given, we won't generate them either.  */
   if (info->nocopyreloc)
     {
-      h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
+      h->non_got_ref = 0;
       return TRUE;
     }
 
-  eh = (struct elf_s390_link_hash_entry *) h;
-  for (p = eh->dyn_relocs; p != NULL; p = p->next)
+  if (ELIMINATE_COPY_RELOCS)
     {
-      s = p->sec->output_section;
-      if (s != NULL && (s->flags & SEC_READONLY) != 0)
-	break;
+      struct elf_s390_link_hash_entry * eh;
+      struct elf_s390_dyn_relocs *p;
+
+      eh = (struct elf_s390_link_hash_entry *) h;
+      for (p = eh->dyn_relocs; p != NULL; p = p->next)
+	{
+	  s = p->sec->output_section;
+	  if (s != NULL && (s->flags & SEC_READONLY) != 0)
+	    break;
+	}
+
+      /* If we didn't find any dynamic relocs in read-only sections, then
+	 we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
+      if (p == NULL)
+	{
+	  h->non_got_ref = 0;
+	  return TRUE;
+	}
     }
 
-  /* If we didn't find any dynamic relocs in read-only sections, then
-     we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
-  if (p == NULL)
+  if (h->size == 0)
     {
-      h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
+      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
+			     h->root.root.string);
       return TRUE;
     }
 
@@ -1602,46 +1669,15 @@ elf_s390_adjust_dynamic_symbol (info, h)
      runtime process image.  */
   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
     {
-      htab->srelbss->_raw_size += sizeof (Elf32_External_Rela);
-      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
+      htab->srelbss->size += sizeof (Elf32_External_Rela);
+      h->needs_copy = 1;
     }
 
-  /* 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 = htab->sdynbss;
-  s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
-  if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
-    {
-      if (! bfd_set_section_alignment (htab->elf.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;
+  return _bfd_elf_adjust_dynamic_copy (h, s);
 }
 
-/* This is the condition under which elf_s390_finish_dynamic_symbol
-   will be called from elflink.h.  If elflink.h doesn't call our
-   finish_dynamic_symbol routine, we'll need to do something about
-   initializing any .plt and .got entries in elf_s390_relocate_section.  */
-#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
-  ((DYN)								\
-   && ((INFO)->shared							\
-       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)	\
-   && ((H)->dynindx != -1						\
-       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
-
 /* Allocate space in .plt, .got and associated reloc sections for
    dynamic relocs.  */
 
@@ -1673,22 +1709,23 @@ allocate_dynrelocs (h, inf)
       /* Make sure this symbol is output as a dynamic symbol.
 	 Undefined weak syms won't yet be marked as dynamic.  */
       if (h->dynindx == -1
-	  && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+	  && !h->forced_local)
 	{
-	  if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
 	    return FALSE;
 	}
 
-      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
+      if (info->shared
+	  || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
 	{
 	  asection *s = htab->splt;
 
 	  /* If this is the first .plt entry, make room for the special
 	     first entry.  */
-	  if (s->_raw_size == 0)
-	    s->_raw_size += PLT_FIRST_ENTRY_SIZE;
+	  if (s->size == 0)
+	    s->size += PLT_FIRST_ENTRY_SIZE;
 
-	  h->plt.offset = s->_raw_size;
+	  h->plt.offset = s->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
@@ -1696,33 +1733,33 @@ allocate_dynrelocs (h, inf)
 	     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->def_regular)
 	    {
 	      h->root.u.def.section = s;
 	      h->root.u.def.value = h->plt.offset;
 	    }
 
 	  /* Make room for this entry.  */
-	  s->_raw_size += PLT_ENTRY_SIZE;
+	  s->size += PLT_ENTRY_SIZE;
 
 	  /* We also need to make an entry in the .got.plt section, which
 	     will be placed in the .got section by the linker script.  */
-	  htab->sgotplt->_raw_size += GOT_ENTRY_SIZE;
+	  htab->sgotplt->size += GOT_ENTRY_SIZE;
 
 	  /* We also need to make an entry in the .rela.plt section.  */
-	  htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
+	  htab->srelplt->size += sizeof (Elf32_External_Rela);
 	}
       else
 	{
  	  h->plt.offset = (bfd_vma) -1;
-	  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+	  h->needs_plt = 0;
 	  elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
 	}
     }
   else
     {
       h->plt.offset = (bfd_vma) -1;
-      h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+      h->needs_plt = 0;
       elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
     }
 
@@ -1740,8 +1777,8 @@ allocate_dynrelocs (h, inf)
 	   to be stored somewhere. The immediate value in the instruction
 	   is not bit enough so the value is stored in the got.  */
 	{
-	  h->got.offset = htab->sgot->_raw_size;
-	  htab->sgot->_raw_size += GOT_ENTRY_SIZE;
+	  h->got.offset = htab->sgot->size;
+	  htab->sgot->size += GOT_ENTRY_SIZE;
 	}
       else
 	h->got.offset = (bfd_vma) -1;
@@ -1755,28 +1792,31 @@ allocate_dynrelocs (h, inf)
       /* Make sure this symbol is output as a dynamic symbol.
 	 Undefined weak syms won't yet be marked as dynamic.  */
       if (h->dynindx == -1
-	  && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+	  && !h->forced_local)
 	{
-	  if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
 	    return FALSE;
 	}
 
       s = htab->sgot;
-      h->got.offset = s->_raw_size;
-      s->_raw_size += GOT_ENTRY_SIZE;
+      h->got.offset = s->size;
+      s->size += GOT_ENTRY_SIZE;
       /* R_390_TLS_GD32 needs 2 consecutive GOT slots.  */
       if (tls_type == GOT_TLS_GD)
-	s->_raw_size += GOT_ENTRY_SIZE;
+	s->size += GOT_ENTRY_SIZE;
       dyn = htab->elf.dynamic_sections_created;
       /* R_390_TLS_IE32 needs one dynamic relocation,
 	 R_390_TLS_GD32 needs one if local symbol and two if global.  */
       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
 	  || tls_type >= GOT_TLS_IE)
-	htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
+	htab->srelgot->size += sizeof (Elf32_External_Rela);
       else if (tls_type == GOT_TLS_GD)
-	htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
-      else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
-	htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
+	htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
+      else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+		|| h->root.type != bfd_link_hash_undefweak)
+	       && (info->shared
+		   || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
+	htab->srelgot->size += sizeof (Elf32_External_Rela);
     }
   else
     h->got.offset = (bfd_vma) -1;
@@ -1793,9 +1833,7 @@ allocate_dynrelocs (h, inf)
 
   if (info->shared)
     {
-      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
-	  && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
-	      || info->symbolic))
+      if (SYMBOL_CALLS_LOCAL (info, h))
 	{
 	  struct elf_s390_dyn_relocs **pp;
 
@@ -1809,16 +1847,34 @@ allocate_dynrelocs (h, inf)
 		pp = &p->next;
 	    }
 	}
+
+      /* Also discard relocs on undefined weak syms with non-default
+	 visibility.  */
+      if (eh->dyn_relocs != NULL
+	  && h->root.type == bfd_link_hash_undefweak)
+	{
+	  if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
+	    eh->dyn_relocs = NULL;
+
+	  /* Make sure undefined weak symbols are output as a dynamic
+	     symbol in PIEs.  */
+	  else if (h->dynindx == -1
+		   && !h->forced_local)
+	    {
+	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
+		return FALSE;
+	    }
+	}
     }
-  else
+  else if (ELIMINATE_COPY_RELOCS)
     {
       /* For the non-shared case, discard space for relocs against
 	 symbols which turn out to need copy relocs or are not
 	 dynamic.  */
 
-      if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
-	  && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
-	       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+      if (!h->non_got_ref
+	  && ((h->def_dynamic
+	       && !h->def_regular)
 	      || (htab->elf.dynamic_sections_created
 		  && (h->root.type == bfd_link_hash_undefweak
 		      || h->root.type == bfd_link_hash_undefined))))
@@ -1826,9 +1882,9 @@ allocate_dynrelocs (h, inf)
 	  /* Make sure this symbol is output as a dynamic symbol.
 	     Undefined weak syms won't yet be marked as dynamic.  */
 	  if (h->dynindx == -1
-	      && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
+	      && !h->forced_local)
 	    {
-	      if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
 		return FALSE;
 	    }
 
@@ -1847,7 +1903,8 @@ allocate_dynrelocs (h, inf)
   for (p = eh->dyn_relocs; p != NULL; p = p->next)
     {
       asection *sreloc = elf_section_data (p->sec)->sreloc;
-      sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
+
+      sreloc->size += p->count * sizeof (Elf32_External_Rela);
     }
 
   return TRUE;
@@ -1905,12 +1962,12 @@ elf_s390_size_dynamic_sections (output_bfd, info)
   if (htab->elf.dynamic_sections_created)
     {
       /* Set the contents of the .interp section to the interpreter.  */
-      if (! info->shared)
+      if (info->executable)
 	{
 	  s = bfd_get_section_by_name (dynobj, ".interp");
 	  if (s == NULL)
 	    abort ();
-	  s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
+	  s->size = sizeof ELF_DYNAMIC_INTERPRETER;
 	  s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 	}
     }
@@ -1926,17 +1983,14 @@ elf_s390_size_dynamic_sections (output_bfd, info)
       Elf_Internal_Shdr *symtab_hdr;
       asection *srela;
 
-      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
+      if (! is_s390_elf (ibfd))
 	continue;
 
       for (s = ibfd->sections; s != NULL; s = s->next)
 	{
 	  struct elf_s390_dyn_relocs *p;
 
-	  for (p = *((struct elf_s390_dyn_relocs **)
-		     &elf_section_data (s)->local_dynrel);
-	       p != NULL;
-	       p = p->next)
+	  for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
 	    {
 	      if (!bfd_is_abs_section (p->sec)
 		  && bfd_is_abs_section (p->sec->output_section))
@@ -1949,7 +2003,7 @@ elf_s390_size_dynamic_sections (output_bfd, info)
 	      else if (p->count != 0)
 		{
 		  srela = elf_section_data (p->sec)->sreloc;
-		  srela->_raw_size += p->count * sizeof (Elf32_External_Rela);
+		  srela->size += p->count * sizeof (Elf32_External_Rela);
 		  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
 		    info->flags |= DF_TEXTREL;
 		}
@@ -1960,7 +2014,7 @@ elf_s390_size_dynamic_sections (output_bfd, info)
       if (!local_got)
 	continue;
 
-      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
+      symtab_hdr = &elf_symtab_hdr (ibfd);
       locsymcount = symtab_hdr->sh_info;
       end_local_got = local_got + locsymcount;
       local_tls_type = elf_s390_local_got_tls_type (ibfd);
@@ -1970,12 +2024,12 @@ elf_s390_size_dynamic_sections (output_bfd, info)
 	{
 	  if (*local_got > 0)
 	    {
-	      *local_got = s->_raw_size;
-	      s->_raw_size += GOT_ENTRY_SIZE;
+	      *local_got = s->size;
+	      s->size += GOT_ENTRY_SIZE;
 	      if (*local_tls_type == GOT_TLS_GD)
-		s->_raw_size += GOT_ENTRY_SIZE;
+		s->size += GOT_ENTRY_SIZE;
 	      if (info->shared)
-		srela->_raw_size += sizeof (Elf32_External_Rela);
+		srela->size += sizeof (Elf32_External_Rela);
 	    }
 	  else
 	    *local_got = (bfd_vma) -1;
@@ -1986,9 +2040,9 @@ elf_s390_size_dynamic_sections (output_bfd, info)
     {
       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM32
 	 relocs.  */
-      htab->tls_ldm_got.offset = htab->sgot->_raw_size;
-      htab->sgot->_raw_size += 2 * GOT_ENTRY_SIZE;
-      htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
+      htab->tls_ldm_got.offset = htab->sgot->size;
+      htab->sgot->size += 2 * GOT_ENTRY_SIZE;
+      htab->srelgot->size += sizeof (Elf32_External_Rela);
     }
   else
     htab->tls_ldm_got.offset = -1;
@@ -2007,14 +2061,15 @@ elf_s390_size_dynamic_sections (output_bfd, info)
 
       if (s == htab->splt
 	  || s == htab->sgot
-	  || s == htab->sgotplt)
+	  || s == htab->sgotplt
+	  || s == htab->sdynbss)
 	{
 	  /* Strip this section if we don't need it; see the
 	     comment below.  */
 	}
-      else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
+      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
 	{
-	  if (s->_raw_size != 0 && s != htab->srelplt)
+	  if (s->size != 0)
 	    relocs = TRUE;
 
 	  /* We use the reloc_count field as a counter if we need
@@ -2027,7 +2082,7 @@ elf_s390_size_dynamic_sections (output_bfd, info)
 	  continue;
 	}
 
-      if (s->_raw_size == 0)
+      if (s->size == 0)
 	{
 	  /* If we don't need this section, strip it from the
 	     output file.  This is to handle .rela.bss and
@@ -2039,16 +2094,19 @@ elf_s390_size_dynamic_sections (output_bfd, info)
 	     function which decides whether anything needs to go
 	     into these sections.  */
 
-	  _bfd_strip_section_from_output (info, s);
+	  s->flags |= SEC_EXCLUDE;
 	  continue;
 	}
 
+      if ((s->flags & SEC_HAS_CONTENTS) == 0)
+	continue;
+
       /* Allocate memory for the section contents.  We use bfd_zalloc
 	 here in case unused entries are not reclaimed before the
 	 section's contents are written out.  This should not happen,
 	 but this way if it does, we get a R_390_NONE reloc instead
 	 of garbage.  */
-      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
+      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
       if (s->contents == NULL)
 	return FALSE;
     }
@@ -2061,15 +2119,15 @@ elf_s390_size_dynamic_sections (output_bfd, info)
 	 the .dynamic section.  The DT_DEBUG entry is filled in by the
 	 dynamic linker and used by the debugger.  */
 #define add_dynamic_entry(TAG, VAL) \
-  bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
+  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
 
-      if (! info->shared)
+      if (info->executable)
 	{
 	  if (!add_dynamic_entry (DT_DEBUG, 0))
 	    return FALSE;
 	}
 
-      if (htab->splt->_raw_size != 0)
+      if (htab->splt->size != 0)
 	{
 	  if (!add_dynamic_entry (DT_PLTGOT, 0)
 	      || !add_dynamic_entry (DT_PLTRELSZ, 0)
@@ -2079,10 +2137,10 @@ elf_s390_size_dynamic_sections (output_bfd, info)
 	}
 
       if (relocs)
-        {
-          if (!add_dynamic_entry (DT_RELA, 0)
-              || !add_dynamic_entry (DT_RELASZ, 0)
-              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
+	{
+	  if (!add_dynamic_entry (DT_RELA, 0)
+	      || !add_dynamic_entry (DT_RELASZ, 0)
+	      || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
 	    return FALSE;
 
 	  /* If any dynamic relocs apply to a read-only section,
@@ -2111,10 +2169,10 @@ static bfd_vma
 dtpoff_base (info)
      struct bfd_link_info *info;
 {
-  /* If tls_segment is NULL, we should have signalled an error already.  */
-  if (elf_hash_table (info)->tls_segment == NULL)
+  /* If tls_sec is NULL, we should have signalled an error already.  */
+  if (elf_hash_table (info)->tls_sec == NULL)
     return 0;
-  return elf_hash_table (info)->tls_segment->start;
+  return elf_hash_table (info)->tls_sec->vma;
 }
 
 /* Return the relocation value for @tpoff relocation
@@ -2125,14 +2183,12 @@ tpoff (info, address)
      struct bfd_link_info *info;
      bfd_vma address;
 {
-  struct elf_link_tls_segment *tls_segment
-    = elf_hash_table (info)->tls_segment;
+  struct elf_link_hash_table *htab = elf_hash_table (info);
 
-  /* If tls_segment is NULL, we should have signalled an error already.  */
-  if (tls_segment == NULL)
+  /* If tls_sec is NULL, we should have signalled an error already.  */
+  if (htab->tls_sec == NULL)
     return 0;
-  return (align_power (tls_segment->size, tls_segment->align)
-	  + tls_segment->start - address);
+  return htab->tls_size + htab->tls_sec->vma - address;
 }
 
 /* Complain if TLS instruction relocation is against an invalid
@@ -2148,11 +2204,12 @@ invalid_tls_insn (input_bfd, input_section, rel)
 
   howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
   (*_bfd_error_handler)
-    (_("%s(%s+0x%lx): invalid instruction for TLS relocation %s"),
-     bfd_archive_filename (input_bfd),
-     bfd_get_section_name (input_bfd, input_section),
+    (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
+     input_bfd,
+     input_section,
      (long) rel->r_offset,
      howto->name);
+  bfd_set_error (bfd_error_bad_value);
 }
 
 /* Relocate a 390 ELF section.  */
@@ -2176,11 +2233,10 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
   Elf_Internal_Rela *rel;
   Elf_Internal_Rela *relend;
 
-  if (info->relocateable)
-    return TRUE;
+  BFD_ASSERT (is_s390_elf (input_bfd));
 
   htab = elf_s390_hash_table (info);
-  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+  symtab_hdr = &elf_symtab_hdr (input_bfd);
   sym_hashes = elf_sym_hashes (input_bfd);
   local_got_offsets = elf_local_got_offsets (input_bfd);
 
@@ -2202,8 +2258,8 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 
       r_type = ELF32_R_TYPE (rel->r_info);
       if (r_type == (int) R_390_GNU_VTINHERIT
-          || r_type == (int) R_390_GNU_VTENTRY)
-        continue;
+	  || r_type == (int) R_390_GNU_VTENTRY)
+	continue;
       if (r_type >= (int) R_390_max)
 	{
 	  bfd_set_error (bfd_error_bad_value);
@@ -2213,7 +2269,6 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
       howto = elf_howto_table + r_type;
       r_symndx = ELF32_R_SYM (rel->r_info);
 
-      /* This is a final link.  */
       h = NULL;
       sym = NULL;
       sec = NULL;
@@ -2222,56 +2277,37 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	{
 	  sym = local_syms + r_symndx;
 	  sec = local_sections[r_symndx];
-	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
+	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 	}
       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;
+	  bfd_boolean warned ATTRIBUTE_UNUSED;
 
-	  if (h->root.type == bfd_link_hash_defined
-	      || h->root.type == bfd_link_hash_defweak)
-	    {
-	      sec = h->root.u.def.section;
-	      if (sec->output_section == NULL)
-		{
-		  /* Set a flag that will be cleared later if we find a
-		     relocation value for this symbol.  output_section
-		     is typically NULL for symbols satisfied by a shared
-		     library.  */
-		  unresolved_reloc = TRUE;
-		  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->allow_shlib_undefined)
-		   && !info->no_undefined
-		   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
-	    relocation = 0;
-	  else
-	    {
-	      if (! ((*info->callbacks->undefined_symbol)
-		     (info, h->root.root.string, input_bfd,
-          	      input_section, rel->r_offset,
-		      (!info->shared || info->no_undefined
-		       || ELF_ST_VISIBILITY (h->other)))))
-		return FALSE;
-	      relocation = 0;
-	    }
+	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
+				   r_symndx, symtab_hdr, sym_hashes,
+				   h, sec, relocation,
+				   unresolved_reloc, warned);
+	}
+
+      if (sec != NULL && elf_discarded_section (sec))
+	{
+	  /* For relocs against symbols from removed linkonce sections,
+	     or sections discarded by a linker script, we just want the
+	     section contents zeroed.  Avoid any special processing.  */
+	  _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
+	  rel->r_info = 0;
+	  rel->r_addend = 0;
+	  continue;
 	}
 
+      if (info->relocatable)
+	continue;
+
       switch (r_type)
 	{
 	case R_390_GOTPLT12:
 	case R_390_GOTPLT16:
+	case R_390_GOTPLT20:
 	case R_390_GOTPLT32:
 	case R_390_GOTPLTENT:
 	  /* There are three cases for a GOTPLT relocation. 1) The
@@ -2291,7 +2327,7 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 		 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.  */
 	      relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
@@ -2303,164 +2339,162 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	    }
 	  /* Fall through.  */
 
-        case R_390_GOT12:
-        case R_390_GOT16:
-        case R_390_GOT32:
+	case R_390_GOT12:
+	case R_390_GOT16:
+	case R_390_GOT20:
+	case R_390_GOT32:
 	case R_390_GOTENT:
-          /* Relocation is to the entry for this symbol in the global
-             offset table.  */
+	  /* Relocation is to the entry for this symbol in the global
+	     offset table.  */
 	  if (htab->sgot == NULL)
 	    abort ();
 
-          if (h != NULL)
-            {
+	  if (h != NULL)
+	    {
 	      bfd_boolean dyn;
 
-              off = h->got.offset;
+	      off = h->got.offset;
 	      dyn = htab->elf.dynamic_sections_created;
-              if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
-                  || (info->shared
-                      && (info->symbolic
-			  || h->dynindx == -1
-			  || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
-                      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
-                {
-                  /* This is actually a static link, or it is a
-                     -Bsymbolic link and the symbol is defined
-                     locally, or the symbol was forced to be local
-                     because of a version file.  We must initialize
-                     this entry in the global offset table.  Since the
-                     offset must always be a multiple of 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
-                    {
+	      if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
+		  || (info->shared
+		      && SYMBOL_REFERENCES_LOCAL (info, h))
+		  || (ELF_ST_VISIBILITY (h->other)
+		      && h->root.type == bfd_link_hash_undefweak))
+		{
+		  /* 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,
 				  htab->sgot->contents + off);
-                      h->got.offset |= 1;
-                    }
-                }
+		      h->got.offset |= 1;
+		    }
+		}
 	      else
 		unresolved_reloc = FALSE;
-            }
-          else
-            {
+	    }
+	  else
+	    {
 	      if (local_got_offsets == NULL)
 		abort ();
 
-              off = local_got_offsets[r_symndx];
+	      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,
+	      /* 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,
 			      htab->sgot->contents + off);
 
-                  if (info->shared)
-                    {
-                      asection *srelgot;
-                      Elf_Internal_Rela outrel;
+		  if (info->shared)
+		    {
+		      asection *srelgot;
+		      Elf_Internal_Rela outrel;
 		      bfd_byte *loc;
 
-                      srelgot = htab->srelgot;
+		      srelgot = htab->srelgot;
 		      if (srelgot == NULL)
 			abort ();
 
-                      outrel.r_offset = (htab->sgot->output_section->vma
-                                         + htab->sgot->output_offset
-                                         + off);
-                      outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
+		      outrel.r_offset = (htab->sgot->output_section->vma
+					 + htab->sgot->output_offset
+					 + off);
+		      outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
 		      outrel.r_addend = relocation;
 		      loc = srelgot->contents;
 		      loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
-                      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
-                    }
+		      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
+		    }
 
-                  local_got_offsets[r_symndx] |= 1;
-                }
-            }
+		  local_got_offsets[r_symndx] |= 1;
+		}
+	    }
 
 	  if (off >= (bfd_vma) -2)
 	    abort ();
 
 	  relocation = htab->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.
-	   */
+	  /* 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
 	      || r_type == R_390_GOTPLTENT)
 	    relocation += htab->sgot->output_section->vma;
 
-          break;
+	  break;
 
 	case R_390_GOTOFF16:
-        case R_390_GOTOFF32:
-          /* Relocation is relative to the start of the global offset
-             table.  */
-
-          /* 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 -= htab->sgot->output_section->vma;
-          break;
-
-        case R_390_GOTPC:
+	case R_390_GOTOFF32:
+	  /* Relocation is relative to the start of the global offset
+	     table.  */
+
+	  /* 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 -= htab->sgot->output_section->vma;
+	  break;
+
+	case R_390_GOTPC:
 	case R_390_GOTPCDBL:
-          /* Use global offset table as symbol value.  */
-          relocation = htab->sgot->output_section->vma;
+	  /* Use global offset table as symbol value.  */
+	  relocation = htab->sgot->output_section->vma;
 	  unresolved_reloc = FALSE;
-          break;
+	  break;
 
-        case R_390_PLT16DBL:
-        case R_390_PLT32DBL:
-        case R_390_PLT32:
-          /* Relocation is to the entry for this symbol in the
-             procedure linkage table.  */
+	case R_390_PLT16DBL:
+	case R_390_PLT32DBL:
+	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;
+	  /* 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
+	  if (h->plt.offset == (bfd_vma) -1
 	      || htab->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 = (htab->splt->output_section->vma
-                        + htab->splt->output_offset
-                        + h->plt.offset);
+	    {
+	      /* We didn't make a PLT entry for this symbol.  This
+		 happens when statically linking PIC code, or when
+		 using -Bsymbolic.  */
+	      break;
+	    }
+
+	  relocation = (htab->splt->output_section->vma
+			+ htab->splt->output_offset
+			+ h->plt.offset);
 	  unresolved_reloc = FALSE;
-          break;
+	  break;
 
 	case R_390_PLTOFF16:
 	case R_390_PLTOFF32:
-          /* Relocation is to the entry for this symbol in the
-             procedure linkage table relative to the start of the GOT.  */
+	  /* Relocation is to the entry for this symbol in the
+	     procedure linkage table relative to the start of the GOT.  */
 
 	  /* For local symbols or if we didn't make a PLT entry for
 	     this symbol resolve the symbol directly.  */
-          if (   h == NULL
+	  if (   h == NULL
 	      || h->plt.offset == (bfd_vma) -1
 	      || htab->splt == NULL)
 	    {
@@ -2468,50 +2502,44 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	      break;
 	    }
 
-          relocation = (htab->splt->output_section->vma
-                        + htab->splt->output_offset
-                        + h->plt.offset
+	  relocation = (htab->splt->output_section->vma
+			+ htab->splt->output_offset
+			+ h->plt.offset
 			- htab->sgot->output_section->vma);
 	  unresolved_reloc = FALSE;
-          break;
-
-        case R_390_8:
-        case R_390_16:
-        case R_390_32:
-        case R_390_PC16:
-        case R_390_PC16DBL:
-        case R_390_PC32DBL:
-        case R_390_PC32:
-	  /* r_symndx will be zero only for relocs against symbols
-	     from removed linkonce sections, or sections discarded by
-	     a linker script.  */
-          if (r_symndx == 0
-              || (input_section->flags & SEC_ALLOC) == 0)
+	  break;
+
+	case R_390_8:
+	case R_390_16:
+	case R_390_32:
+	case R_390_PC16:
+	case R_390_PC16DBL:
+	case R_390_PC32DBL:
+	case R_390_PC32:
+	  if ((input_section->flags & SEC_ALLOC) == 0)
 	    break;
 
-          if ((info->shared
+	  if ((info->shared
+	       && (h == NULL
+		   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+		   || h->root.type != bfd_link_hash_undefweak)
 	       && ((r_type != R_390_PC16
 		    && r_type != R_390_PC16DBL
 		    && r_type != R_390_PC32DBL
 		    && r_type != R_390_PC32)
-		   || (h != NULL
-		       && h->dynindx != -1
-		       && (! info->symbolic
-			   || (h->elf_link_hash_flags
-			       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
-	      || (!info->shared
+		   || !SYMBOL_CALLS_LOCAL (info, h)))
+	      || (ELIMINATE_COPY_RELOCS
+		  && !info->shared
 		  && h != NULL
 		  && h->dynindx != -1
-		  && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
-		  && (((h->elf_link_hash_flags
-		       & ELF_LINK_HASH_DEF_DYNAMIC) != 0
-		       && (h->elf_link_hash_flags
-			   & ELF_LINK_HASH_DEF_REGULAR) == 0)
+		  && !h->non_got_ref
+		  && ((h->def_dynamic
+		       && !h->def_regular)
 		      || h->root.type == bfd_link_hash_undefweak
 		      || h->root.type == bfd_link_hash_undefined)))
-            {
-              Elf_Internal_Rela outrel;
-              bfd_boolean skip, relocate;
+	    {
+	      Elf_Internal_Rela outrel;
+	      bfd_boolean skip, relocate;
 	      asection *sreloc;
 	      bfd_byte *loc;
 
@@ -2519,8 +2547,8 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 		 are copied into the output file to be resolved at run
 		 time.  */
 
-              skip = FALSE;
-              relocate = FALSE;
+	      skip = FALSE;
+	      relocate = FALSE;
 
 	      outrel.r_offset =
 		_bfd_elf_section_offset (output_bfd, info, input_section,
@@ -2529,32 +2557,67 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 		skip = TRUE;
 	      else if (outrel.r_offset == (bfd_vma) -2)
 		skip = TRUE, relocate = TRUE;
-              outrel.r_offset += (input_section->output_section->vma
-                                  + input_section->output_offset);
+	      outrel.r_offset += (input_section->output_section->vma
+				  + input_section->output_offset);
 
-              if (skip)
+	      if (skip)
 		memset (&outrel, 0, sizeof outrel);
-              else if (h != NULL
+	      else if (h != NULL
 		       && h->dynindx != -1
 		       && (r_type == R_390_PC16
 			   || r_type == R_390_PC16DBL
 			   || r_type == R_390_PC32DBL
 			   || r_type == R_390_PC32
 			   || !info->shared
-			   || !info->symbolic
-			   || (h->elf_link_hash_flags
-			       & ELF_LINK_HASH_DEF_REGULAR) == 0))
-                {
-                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
+			   || !SYMBOLIC_BIND (info, h)
+			   || !h->def_regular))
+		{
+		  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
 		  outrel.r_addend = rel->r_addend;
-                }
-              else
-                {
+		}
+	      else
+		{
 		  /* This symbol is local, or marked to become local.  */
-		  relocate = TRUE;
-		  outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
 		  outrel.r_addend = relocation + rel->r_addend;
-                }
+		  if (r_type == R_390_32)
+		    {
+		      relocate = TRUE;
+		      outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
+		    }
+		  else
+		    {
+		      long sindx;
+
+		      if (bfd_is_abs_section (sec))
+			sindx = 0;
+		      else if (sec == NULL || sec->owner == NULL)
+			{
+			  bfd_set_error(bfd_error_bad_value);
+			  return FALSE;
+			}
+		      else
+			{
+			  asection *osec;
+
+			  osec = sec->output_section;
+			  sindx = elf_section_data (osec)->dynindx;
+			  if (sindx == 0)
+			    {
+			      osec = htab->elf.text_index_section;
+			      sindx = elf_section_data (osec)->dynindx;
+			    }
+			  BFD_ASSERT (sindx != 0);
+
+			  /* We are turning this relocation into one
+			     against a section symbol, so subtract out
+			     the output section's address but not the
+			     offset of the input section in the output
+			     section.  */
+			  outrel.r_addend -= osec->vma;
+			}
+		      outrel.r_info = ELF32_R_INFO (sindx, r_type);
+		    }
+		}
 
 	      sreloc = elf_section_data (input_section)->sreloc;
 	      if (sreloc == NULL)
@@ -2564,13 +2627,13 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	      loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
 	      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
 
-              /* 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;
-            }
+	      /* 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;
 
 	  /* Relocations for tls literal pool entries.  */
@@ -2592,7 +2655,7 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	      loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
 	      bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
 	    }
-	  /* Fall through */
+	  /* Fall through.  */
 
 	case R_390_TLS_GD32:
 	case R_390_TLS_GOTIE32:
@@ -2636,7 +2699,7 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 
 	  if ((off & 1) != 0)
 	    off &= ~1;
-          else
+	  else
 	    {
 	      Elf_Internal_Rela outrel;
 	      bfd_byte *loc;
@@ -2667,7 +2730,7 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 		{
 		  if (indx == 0)
 		    {
-	    	      BFD_ASSERT (! unresolved_reloc);
+		      BFD_ASSERT (! unresolved_reloc);
 		      bfd_put_32 (output_bfd,
 				  relocation - dtpoff_base (info),
 				  htab->sgot->contents + off + GOT_ENTRY_SIZE);
@@ -2707,6 +2770,7 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	  break;
 
 	case R_390_TLS_GOTIE12:
+	case R_390_TLS_GOTIE20:
 	case R_390_TLS_IEENT:
 	  if (h == NULL)
 	    {
@@ -2771,7 +2835,7 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	      htab->tls_ldm_got.offset |= 1;
 	    }
 	  relocation = htab->sgot->output_offset + off;
-	  unresolved_reloc = FALSE;	  
+	  unresolved_reloc = FALSE;
 	  break;
 
 	case R_390_TLS_LE32:
@@ -2812,7 +2876,7 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	  continue;
 
 	case R_390_TLS_LDO32:
-	  if (info->shared || (input_section->flags & SEC_CODE) == 0)
+	  if (info->shared)
 	    relocation -= dtpoff_base (info);
 	  else
 	    /* When converting LDO to LE, we must negate.  */
@@ -2868,16 +2932,44 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	      unsigned int insn;
 
 	      insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
-	      if ((insn & 0xff000fff) != 0x4d000000)
+	      if ((insn & 0xff000fff) != 0x4d000000 &&
+		  (insn & 0xffff0000) != 0xc0e50000)
 		invalid_tls_insn (input_bfd, input_section, rel);
 	      if (!info->shared && (h == NULL || h->dynindx == -1))
-		/* GD->LE transition.
-		   bas %r14,0(%rx,%r13) -> bc 0,0  */
-		insn = 0x47000000;
+		{
+		  if ((insn & 0xff000000) == 0x4d000000)
+		    {
+		      /* GD->LE transition.
+			 bas %r14,0(%rx,%r13) -> bc 0,0  */
+		      insn = 0x47000000;
+		    }
+		  else
+		    {
+		      /* GD->LE transition.
+			 brasl %r14,_tls_get_addr@plt -> brcl 0,.  */
+		      insn = 0xc0040000;
+		      bfd_put_16 (output_bfd, 0x0000,
+				  contents + rel->r_offset + 4);
+		    }
+		}
 	      else
-		/* GD->IE transition.
-		   bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
-		insn = 0x5822c000;
+		{
+		  if ((insn & 0xff000000) == 0x4d000000)
+		    {
+		      /* GD->IE transition.
+			 bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
+		      insn = 0x5822c000;
+		    }
+		  else
+		    {
+		      /* GD->IE transition.
+			 brasl %r14,__tls_get_addr@plt ->
+			 	l %r2,0(%r2,%r12) ; bcr 0,0 */
+		      insn = 0x5822c000;
+		      bfd_put_16 (output_bfd, 0x0700,
+				  contents + rel->r_offset + 4);
+		    }
+		}
 	      bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
 	    }
 	  else if (r_type == R_390_TLS_LDCALL)
@@ -2887,11 +2979,23 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 		  unsigned int insn;
 
 		  insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
-		  if ((insn & 0xff000fff) != 0x4d000000)
+		  if ((insn & 0xff000fff) != 0x4d000000 &&
+		      (insn & 0xffff0000) != 0xc0e50000)
 		    invalid_tls_insn (input_bfd, input_section, rel);
-		  /* LD->LE transition.
-		     bas %r14,0(%rx,%r13) -> bc 0,0  */
-		  insn = 0x47000000;
+		  if ((insn & 0xff000000) == 0x4d000000)
+		    {
+		      /* LD->LE transition.
+			 bas %r14,0(%rx,%r13) -> bc 0,0  */
+		      insn = 0x47000000;
+		    }
+		  else
+		    {
+		      /* LD->LE transition.
+			 brasl %r14,__tls_get_addr@plt -> brcl 0,. */
+		      insn = 0xc0040000;
+		      bfd_put_16 (output_bfd, 0x0000,
+				  contents + rel->r_offset + 4);
+		    }
 		  bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
 		}
 	    }
@@ -2906,17 +3010,30 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	 not process them.  */
       if (unresolved_reloc
 	  && !((input_section->flags & SEC_DEBUGGING) != 0
-	       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
+	       && h->def_dynamic))
 	(*_bfd_error_handler)
-	  (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
-	   bfd_archive_filename (input_bfd),
-	   bfd_get_section_name (input_bfd, input_section),
+	  (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
+	   input_bfd,
+	   input_section,
 	   (long) rel->r_offset,
+	   howto->name,
 	   h->root.root.string);
 
-      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
-				    contents, rel->r_offset,
-				    relocation, rel->r_addend);
+      if (r_type == R_390_20
+	  || r_type == R_390_GOT20
+	  || r_type == R_390_GOTPLT20
+	  || r_type == R_390_TLS_GOTIE20)
+	{
+	  relocation += rel->r_addend;
+	  relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
+	  r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+					contents, rel->r_offset,
+					relocation, 0);
+	}
+      else
+	r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+				      contents, rel->r_offset,
+				      relocation, rel->r_addend);
 
       if (r != bfd_reloc_ok)
 	{
@@ -2939,16 +3056,16 @@ elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
 	    {
 
 	      if (! ((*info->callbacks->reloc_overflow)
-		     (info, name, howto->name, (bfd_vma) 0,
-		      input_bfd, input_section, rel->r_offset)))
+		     (info, (h ? &h->root : NULL), name, howto->name,
+		      (bfd_vma) 0, input_bfd, input_section,
+		      rel->r_offset)))
 		return FALSE;
 	    }
 	  else
 	    {
 	      (*_bfd_error_handler)
-		(_("%s(%s+0x%lx): reloc against `%s': error %d"),
-		 bfd_archive_filename (input_bfd),
-		 bfd_get_section_name (input_bfd, input_section),
+		(_("%B(%A+0x%lx): reloc against `%s': error %d"),
+		 input_bfd, input_section,
 		 (long) rel->r_offset, name, (int) r);
 	      return FALSE;
 	    }
@@ -2981,8 +3098,7 @@ elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
       bfd_vma relative_offset;
 
       /* This symbol has an entry in the procedure linkage table.  Set
-         it up.  */
-
+	 it up.  */
       if (h->dynindx == -1
 	  || htab->splt == NULL
 	  || htab->sgotplt == NULL
@@ -2990,26 +3106,26 @@ elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
 	abort ();
 
       /* Calc. index no.
-         Current offset - size first entry / entry size.  */
+	 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.  */
+	 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);
+			    (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
       /* If offset is > 32768, branch to a previous branch
-         390 can only handle +-64 K jumps.  */
+	 390 can only handle +-64 K jumps.  */
       if ( -32768 > (int) relative_offset )
-          relative_offset =
-	    -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
+	relative_offset
+	  = -(unsigned) (((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, (bfd_vma) PLT_ENTRY_WORD0,
+	  bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD0,
 		      htab->splt->contents + h->plt.offset);
 	  bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD1,
 		      htab->splt->contents + h->plt.offset + 4);
@@ -3080,10 +3196,10 @@ elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
 	}
       /* Insert offset into  reloc. table here.  */
       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
-                  htab->splt->contents + h->plt.offset + 28);
+		  htab->splt->contents + h->plt.offset + 28);
 
       /* Fill in the entry in the global offset table.
-         Points to instruction after GOT offset.  */
+	 Points to instruction after GOT offset.  */
       bfd_put_32 (output_bfd,
 		  (htab->splt->output_section->vma
 		   + htab->splt->output_offset
@@ -3100,7 +3216,7 @@ elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
 
-      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+      if (!h->def_regular)
 	{
 	  /* Mark the symbol as undefined, rather than as defined in
 	     the .plt section.  Leave the value alone.  This is a clue
@@ -3120,7 +3236,7 @@ elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
       bfd_byte *loc;
 
       /* This symbol has an entry in the global offset table.  Set it
-         up.  */
+	 up.  */
 
       if (htab->sgot == NULL || htab->srelgot == NULL)
 	abort ();
@@ -3135,31 +3251,30 @@ elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
 	 The entry in the global offset table will already have been
 	 initialized in the relocate_section function.  */
       if (info->shared
-	  && (info->symbolic
-	      || h->dynindx == -1
-	      || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
-	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
+	  && SYMBOL_REFERENCES_LOCAL (info, h))
 	{
+	  if (!h->def_regular)
+	    return FALSE;
 	  BFD_ASSERT((h->got.offset & 1) != 0);
 	  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);
-        }
+			   + 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, htab->sgot->contents + h->got.offset);
 	  rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
-          rela.r_addend = 0;
-        }
+	  rela.r_addend = 0;
+	}
 
       loc = htab->srelgot->contents;
       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
     }
 
-  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
+  if (h->needs_copy)
     {
       Elf_Internal_Rela rela;
       bfd_byte *loc;
@@ -3184,8 +3299,8 @@ elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
 
   /* 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)
+      || h == htab->elf.hgot
+      || h == htab->elf.hplt)
     sym->st_shndx = SHN_ABS;
 
   return TRUE;
@@ -3234,7 +3349,7 @@ elf_s390_finish_dynamic_sections (output_bfd, info)
 	abort ();
 
       dyncon = (Elf32_External_Dyn *) sdyn->contents;
-      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
+      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
       for (; dyncon < dynconend; dyncon++)
 	{
 	  Elf_Internal_Dyn dyn;
@@ -3257,10 +3372,7 @@ elf_s390_finish_dynamic_sections (output_bfd, info)
 
 	    case DT_PLTRELSZ:
 	      s = htab->srelplt->output_section;
-	      if (s->_cooked_size != 0)
-		dyn.d_un.d_val = s->_cooked_size;
-	      else
-		dyn.d_un.d_val = s->_raw_size;
+	      dyn.d_un.d_val = s->size;
 	      break;
 	    }
 
@@ -3268,41 +3380,41 @@ elf_s390_finish_dynamic_sections (output_bfd, info)
 	}
 
       /* Fill in the special first entry in the procedure linkage table.  */
-      if (htab->splt && htab->splt->_raw_size > 0)
+      if (htab->splt && htab->splt->size > 0)
 	{
-          memset (htab->splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
-          if (info->shared)
+	  memset (htab->splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
+	  if (info->shared)
 	    {
 	      bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD0,
-		          htab->splt->contents );
+			  htab->splt->contents );
 	      bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD1,
-		          htab->splt->contents +4 );
+			  htab->splt->contents +4 );
 	      bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD2,
-		          htab->splt->contents +8 );
+			  htab->splt->contents +8 );
 	      bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD3,
-		          htab->splt->contents +12 );
+			  htab->splt->contents +12 );
 	      bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD4,
-		          htab->splt->contents +16 );
-           }
-          else
-           {
-              bfd_put_32 (output_bfd, (bfd_vma)PLT_FIRST_ENTRY_WORD0,
-                          htab->splt->contents );
-              bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
-                          htab->splt->contents +4 );
-              bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD2,
-                          htab->splt->contents +8 );
-              bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
-                          htab->splt->contents +12 );
-              bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
-                          htab->splt->contents +16 );
-              bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
-                          htab->splt->contents +20 );
-              bfd_put_32 (output_bfd,
-                          htab->sgotplt->output_section->vma
+			  htab->splt->contents +16 );
+	   }
+	  else
+	   {
+	      bfd_put_32 (output_bfd, (bfd_vma)PLT_FIRST_ENTRY_WORD0,
+			  htab->splt->contents );
+	      bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
+			  htab->splt->contents +4 );
+	      bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD2,
+			  htab->splt->contents +8 );
+	      bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
+			  htab->splt->contents +12 );
+	      bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
+			  htab->splt->contents +16 );
+	      bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
+			  htab->splt->contents +20 );
+	      bfd_put_32 (output_bfd,
+			  htab->sgotplt->output_section->vma
 			  + htab->sgotplt->output_offset,
-                          htab->splt->contents + 24);
-           }
+			  htab->splt->contents + 24);
+	   }
 	  elf_section_data (htab->splt->output_section)
 	    ->this_hdr.sh_entsize = 4;
 	}
@@ -3312,7 +3424,7 @@ elf_s390_finish_dynamic_sections (output_bfd, info)
   if (htab->sgotplt)
     {
       /* Fill in the first three entries in the global offset table.  */
-      if (htab->sgotplt->_raw_size > 0)
+      if (htab->sgotplt->size > 0)
 	{
 	  bfd_put_32 (output_bfd,
 		      (sdyn == NULL ? (bfd_vma) 0
@@ -3336,7 +3448,7 @@ elf_s390_grok_prstatus (abfd, note)
      Elf_Internal_Note * note;
 {
   int offset;
-  unsigned int raw_size;
+  unsigned int size;
 
   switch (note->descsz)
     {
@@ -3352,15 +3464,26 @@ elf_s390_grok_prstatus (abfd, note)
 
 	/* pr_reg */
 	offset = 72;
-	raw_size = 144;
+	size = 144;
 	break;
     }
 
   /* Make a ".reg/999" section.  */
   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
-					  raw_size, note->descpos + offset);
+					  size, note->descpos + offset);
 }
 
+/* Return address for Ith PLT stub in section PLT, for relocation REL
+   or (bfd_vma) -1 if it should not be included.  */
+
+static bfd_vma
+elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
+		      const arelent *rel ATTRIBUTE_UNUSED)
+{
+  return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
+}
+
+
 #define TARGET_BIG_SYM	bfd_elf32_s390_vec
 #define TARGET_BIG_NAME	"elf32-s390"
 #define ELF_ARCH	bfd_arch_s390
@@ -3374,30 +3497,32 @@ elf_s390_grok_prstatus (abfd, note)
 #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_backend_rela_normal		1
 
-#define elf_info_to_howto                     elf_s390_info_to_howto
+#define elf_info_to_howto		      elf_s390_info_to_howto
 
 #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 bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
 
 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
-#define elf_backend_check_relocs              elf_s390_check_relocs
+#define elf_backend_check_relocs	      elf_s390_check_relocs
 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
 #define elf_backend_create_dynamic_sections   elf_s390_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_gc_mark_hook	      elf_s390_gc_mark_hook
+#define elf_backend_gc_sweep_hook	      elf_s390_gc_sweep_hook
 #define elf_backend_reloc_type_class	      elf_s390_reloc_type_class
-#define elf_backend_relocate_section          elf_s390_relocate_section
+#define elf_backend_relocate_section	      elf_s390_relocate_section
 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
+#define elf_backend_init_index_section	      _bfd_elf_init_1_index_section
 #define elf_backend_reloc_type_class	      elf_s390_reloc_type_class
 #define elf_backend_grok_prstatus	      elf_s390_grok_prstatus
+#define elf_backend_plt_sym_val		      elf_s390_plt_sym_val
 
 #define bfd_elf32_mkobject		elf_s390_mkobject
-#define elf_backend_object_p            elf_s390_object_p
+#define elf_backend_object_p		elf_s390_object_p
 
 #include "elf32-target.h"