* elf64-alpha.c (alpha_elf_dynamic_symbol_p): Undef weak symbols

        are always dynamic.
        (elf64_alpha_calc_dynrel_sizes): Allow enough room for RELATIVE
        .got relocs in -Bsymbolic shared objects.

2 files changed, 229 insertions, 188 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 9701b93..30f5694 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,10 @@
+Sat Aug  8 15:15:30 1998  Richard Henderson  <rth@cygnus.com>
+
+	* elf64-alpha.c (alpha_elf_dynamic_symbol_p): Undef weak symbols
+	are always dynamic.
+	(elf64_alpha_calc_dynrel_sizes): Allow enough room for RELATIVE
+	.got relocs in -Bsymbolic shared objects.
+
 start-sanitize-armelf
 Wed Aug  5 15:48:08 1998  Nick Clifton  <nickc@cygnus.com>
 
diff --git a/bfd/elf64-alpha.c b/bfd/elf64-alpha.c
index a4aa3aa..dc9c6cc 100644
--- a/bfd/elf64-alpha.c
+++ b/bfd/elf64-alpha.c
@@ -229,7 +229,8 @@ struct alpha_elf_link_hash_table
   (((info)->shared && !(info)->symbolic && (h)->dynindx != -1)		\
    || (((h)->elf_link_hash_flags					\
 	& (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))	\
-       == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
+       == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))	\
+   || (h)->root.type == bfd_link_hash_undefweak)
 
 /* Create an entry in a Alpha ELF linker hash table.  */
 
@@ -1043,9 +1044,9 @@ struct alpha_relax_info
   bfd_vma gp;
   bfd *gotobj;
   asection *tsec;
-  Elf_Internal_Sym *elfsym;
   struct alpha_elf_link_hash_entry *h;
   struct alpha_elf_got_entry *gotent;
+  unsigned char other;
 };
 
 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
@@ -1282,12 +1283,12 @@ elf64_alpha_relax_opt_call (info, symval)
 
   /* If the symbol is marked NOPV, we are being told the function never
      needs its procedure value.  */
-  if (info->elfsym->st_other == STO_ALPHA_NOPV)
+  if (info->other == STO_ALPHA_NOPV)
     return symval;
 
   /* If the symbol is marked STD_GP, we are being told the function does
      a normal ldgp in the first two words.  */ 
-  else if (info->elfsym->st_other == STO_ALPHA_STD_GPLOAD)
+  else if (info->other == STO_ALPHA_STD_GPLOAD)
     ;
 
   /* Otherwise, we may be able to identify a GP load in the first two
@@ -1298,14 +1299,23 @@ elf64_alpha_relax_opt_call (info, symval)
       bfd_vma ofs;
 
       /* Load the relocations from the section that the target symbol is in. */
-      tsec_relocs = (_bfd_elf64_link_read_relocs
-	             (info->abfd, info->tsec, (PTR) NULL,
-		     (Elf_Internal_Rela *) NULL,
-		     info->link_info->keep_memory));
-      if (tsec_relocs == NULL)
-	return 0;
-      tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
-      tsec_relend = tsec_relocs + info->tsec->reloc_count;
+      if (info->sec == info->tsec)
+	{
+	  tsec_relocs = info->relocs;
+	  tsec_relend = info->relend;
+	  tsec_free = NULL;
+	}
+      else
+	{
+	  tsec_relocs = (_bfd_elf64_link_read_relocs
+		         (info->abfd, info->tsec, (PTR) NULL,
+			 (Elf_Internal_Rela *) NULL,
+			 info->link_info->keep_memory));
+	  if (tsec_relocs == NULL)
+	    return 0;
+	  tsec_relend = tsec_relocs + info->tsec->reloc_count;
+	  tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
+	}
 
       /* Recover the symbol's offset within the section.  */
       ofs = (symval - info->tsec->output_section->vma
@@ -1527,7 +1537,7 @@ elf64_alpha_relax_section (abfd, sec, link_info, again)
 
 	  info.h = NULL;
 	  info.gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
-	  info.elfsym = &isym;
+	  info.other = isym.st_other;
 	  symval = isym.st_value;
 	}
       else
@@ -1555,7 +1565,7 @@ elf64_alpha_relax_section (abfd, sec, link_info, again)
 	  info.h = h;
 	  info.gotent = gotent;
 	  info.tsec = h->root.root.u.def.section;
-	  info.elfsym = &((elf_symbol_type *) h)->internal_elf_sym;
+	  info.other = h->root.other;
 	  symval = h->root.root.u.def.value;
 	}
       symval += info.tsec->output_section->vma + info.tsec->output_offset;
@@ -1618,6 +1628,8 @@ elf64_alpha_relax_section (abfd, sec, link_info, again)
 	}
     }
 
+  *again = info.changed_contents || info.changed_relocs;
+
   return true;
 
  error_return:
@@ -2279,7 +2291,7 @@ elf64_alpha_output_extsym (h, data)
 	{
 	  output_section = sec->output_section;
 	  if (output_section != NULL)
-	    h->esym.asym.value = (h->root.plt_offset
+	    h->esym.asym.value = (h->root.plt.offset
 				  + sec->output_offset
 				  + output_section->vma);
 	  else
@@ -2636,7 +2648,7 @@ elf64_alpha_adjust_dynamic_symbol (info, h)
       if (s->_raw_size == 0)
 	s->_raw_size = PLT_HEADER_SIZE;
 
-      h->plt_offset = s->_raw_size;
+      h->plt.offset = s->_raw_size;
       s->_raw_size += PLT_ENTRY_SIZE;
 
       /* If this symbol is not defined in a regular file, and we are not
@@ -2646,7 +2658,7 @@ elf64_alpha_adjust_dynamic_symbol (info, h)
       if (!info->shared)
 	{
 	  h->root.u.def.section = s;
-	  h->root.u.def.value = h->plt_offset;
+	  h->root.u.def.value = h->plt.offset;
 	}
 
       /* We also need a JMP_SLOT entry in the .rela.plt section.  */
@@ -2759,6 +2771,7 @@ elf64_alpha_can_merge_gots (a, b)
      bfd *a, *b;
 {
   int total = alpha_elf_tdata (a)->total_got_entries;
+  bfd *bsub;
 
   /* Trivial quick fallout test.  */
   if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
@@ -2771,39 +2784,40 @@ elf64_alpha_can_merge_gots (a, b)
   /* Failing the common trivial comparison, we must effectively
      perform the merge.  Not actually performing the merge means that
      we don't have to store undo information in case we fail.  */
-  {
-    struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes(b);
-    Elf_Internal_Shdr *symtab_hdr = &elf_tdata(b)->symtab_hdr;
-    int i, n;
+  for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
+    {
+      struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
+      Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
+      int i, n;
 
-    n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
-    for (i = 0; i < n; ++i)
-      {
-	struct alpha_elf_got_entry *ae, *be;
-	struct alpha_elf_link_hash_entry *h;
+      n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
+      for (i = 0; i < n; ++i)
+	{
+	  struct alpha_elf_got_entry *ae, *be;
+	  struct alpha_elf_link_hash_entry *h;
 
-	h = hashes[i];
-	while (h->root.root.type == bfd_link_hash_indirect
-	       || h->root.root.type == bfd_link_hash_warning)
-	  h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
+	  h = hashes[i];
+	  while (h->root.root.type == bfd_link_hash_indirect
+	         || h->root.root.type == bfd_link_hash_warning)
+	    h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
 
-	for (be = h->got_entries; be ; be = be->next)
-	  {
-	    if (be->use_count == 0)
-	      continue;
-	    if (be->gotobj != b)
-	      continue;
+	  for (be = h->got_entries; be ; be = be->next)
+	    {
+	      if (be->use_count == 0)
+	        continue;
+	      if (be->gotobj != b)
+	        continue;
 
-	    for (ae = h->got_entries; ae ; ae = ae->next)
-	      if (ae->gotobj == a && ae->addend == be->addend)
-		goto global_found;
+	      for (ae = h->got_entries; ae ; ae = ae->next)
+	        if (ae->gotobj == a && ae->addend == be->addend)
+		  goto global_found;
 
-	    if (++total > MAX_GOT_ENTRIES)
-	      return false;
-	  global_found:;
-	  }
-      }
-  }
+	      if (++total > MAX_GOT_ENTRIES)
+	        return false;
+	    global_found:;
+	    }
+	}
+    }
 
   return true;
 }
@@ -2814,79 +2828,91 @@ static void
 elf64_alpha_merge_gots (a, b)
      bfd *a, *b;
 {
-  int total = alpha_elf_tdata(a)->total_got_entries;
+  int total = alpha_elf_tdata (a)->total_got_entries;
+  bfd *bsub;
 
   /* Remember local expansion.  */
   {
-    int e = alpha_elf_tdata(b)->n_local_got_entries;
+    int e = alpha_elf_tdata (b)->n_local_got_entries;
     total += e;
-    alpha_elf_tdata(a)->n_local_got_entries += e;
+    alpha_elf_tdata (a)->n_local_got_entries += e;
   }
 
-  /* Let the local .got entries know they are part of a new subsegment.  */
-  {
-    struct alpha_elf_got_entry **local_got_entries;
-    local_got_entries = alpha_elf_tdata(b)->local_got_entries;
-    if (local_got_entries)
-      {
-	int i, n;
+  for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
+    {
+      struct alpha_elf_got_entry **local_got_entries;
+      struct alpha_elf_link_hash_entry **hashes;
+      Elf_Internal_Shdr *symtab_hdr;
+      int i, n;
+
+      /* Let the local .got entries know they are part of a new subsegment.  */
+      local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
+      if (local_got_entries)
+        {
+	  n = elf_tdata (bsub)->symtab_hdr.sh_info;
+	  for (i = 0; i < n; ++i)
+	    {
+	      struct alpha_elf_got_entry *ent;
+	      for (ent = local_got_entries[i]; ent; ent = ent->next)
+	        ent->gotobj = a;
+	    }
+        }
 
-	n = elf_tdata(b)->symtab_hdr.sh_info;
-	for (i = 0; i < n; ++i)
-	  {
-	    struct alpha_elf_got_entry *gotent;
-	    for (gotent = local_got_entries[i]; gotent; gotent = gotent->next)
-	      gotent->gotobj = a;
-	  }
-      }
-  }
+      /* Merge the global .got entries.  */
+      hashes = alpha_elf_sym_hashes (bsub);
+      symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
 
-  /* Merge the global .got entries.  */
-  {
-    struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes(b);
-    Elf_Internal_Shdr *symtab_hdr = &elf_tdata(b)->symtab_hdr;
-    int i, n;
+      n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
+      for (i = 0; i < n; ++i)
+        {
+	  struct alpha_elf_got_entry *ae, *be, **pbe, **start;
+	  struct alpha_elf_link_hash_entry *h;
 
-    n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
-    for (i = 0; i < n; ++i)
-      {
-	struct alpha_elf_got_entry *ae, *be, **pbe, **start;
-	struct alpha_elf_link_hash_entry *h;
+	  h = hashes[i];
+	  while (h->root.root.type == bfd_link_hash_indirect
+	         || h->root.root.type == bfd_link_hash_warning)
+	    h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
 
-	h = hashes[i];
-	while (h->root.root.type == bfd_link_hash_indirect
-	       || h->root.root.type == bfd_link_hash_warning)
-	  h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
+	  start = &h->got_entries;
+	  for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
+	    {
+	      if (be->use_count == 0)
+	        {
+		  *pbe = be->next;
+		  continue;
+	        }
+	      if (be->gotobj != b)
+	        continue;
 
-	start = &h->got_entries;
-	for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
-	  {
-	    if (be->use_count == 0)
-	      {
-		*pbe = be->next;
-		continue;
-	      }
-	    if (be->gotobj != b)
-	      continue;
+	      for (ae = *start; ae ; ae = ae->next)
+	        if (ae->gotobj == a && ae->addend == be->addend)
+		  {
+		    ae->flags |= be->flags;
+		    ae->use_count += be->use_count;
+		    *pbe = be->next;
+		    goto global_found;
+		  }
+	      be->gotobj = a;
+	      total += 1;
 
-	    for (ae = *start; ae ; ae = ae->next)
-	      if (ae->gotobj == a && ae->addend == be->addend)
-		{
-		  ae->flags |= be->flags;
-		  ae->use_count += be->use_count;
-		  *pbe = be->next;
-		  goto global_found;
-		}
-	    be->gotobj = a;
-	    total += 1;
+	    global_found:;
+	    }
+        }
 
-	  global_found:;
-	  }
-      }
-  }
+      alpha_elf_tdata (bsub)->gotobj = a;
+    }
+  alpha_elf_tdata (a)->total_got_entries = total;
+
+  /* Merge the two in_got chains.  */
+  {
+    bfd *next;
+
+    bsub = a;
+    while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
+      bsub = next;
 
-  alpha_elf_tdata(a)->total_got_entries = total;
-  alpha_elf_tdata(b)->gotobj = a;
+    alpha_elf_tdata (bsub)->in_got_link_next = b;
+  }
 }
 
 /* Calculate the offsets for the got entries.  */
@@ -2979,69 +3005,73 @@ elf64_alpha_size_got_sections (output_bfd, info)
      bfd *output_bfd;
      struct bfd_link_info *info;
 {
-  bfd *i, *got_list, *cur_got_obj, **cur_got_tail;
-  int ngots;
-
-  ngots = 0;
-  got_list = NULL;
-  cur_got_obj = NULL;
-  cur_got_tail = NULL;
-  for (i = info->input_bfds; i ; i = i->link_next)
-    {
-      bfd *this_got = alpha_elf_tdata (i)->gotobj;
+  bfd *i, *got_list, *cur_got_obj;
+  int something_changed = 0;
 
-      /* Don't play if there is no .got for this input file.  */
-      if (this_got == NULL)
-	continue;
+  got_list = alpha_elf_hash_table (info)->got_list;
 
-      if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
+  /* On the first time through, pretend we have an existing got list
+     consisting of all of the input files.  */
+  if (got_list == NULL)
+    {
+      for (i = info->input_bfds; i ; i = i->link_next)
 	{
-	  /* Yikes! A single object file has too many entries.  */
-	  (*_bfd_error_handler)
-	    (_("%s: .got subsegment exceeds 64K (size %d)"),
-	     bfd_get_filename(i),
-	     alpha_elf_tdata(this_got)->total_got_entries * 8);
-	  return false;
-	}
+	  bfd *this_got = alpha_elf_tdata (i)->gotobj;
+	  if (this_got == NULL)
+	    continue;
 
-      if (cur_got_obj)
-	{
-	  if (this_got == cur_got_obj)
-	    ; /* Some previous pass merged us already.  */
-	  else if (elf64_alpha_can_merge_gots (cur_got_obj, i))
+	  /* We are assuming no merging has yet ocurred.  */
+	  BFD_ASSERT (this_got == i);
+
+          if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
 	    {
-	      elf64_alpha_merge_gots (cur_got_obj, i);
-	      *cur_got_tail = i;
+	      /* Yikes! A single object file has too many entries.  */
+	      (*_bfd_error_handler)
+	        (_("%s: .got subsegment exceeds 64K (size %d)"),
+	         bfd_get_filename (i),
+	         alpha_elf_tdata (this_got)->total_got_entries * 8);
+	      return false;
 	    }
+
+	  if (got_list == NULL)
+	    got_list = this_got;
 	  else
-	    {
-	      if (++ngots == 2)
-		{
-		  (*info->callbacks->warning)
-		    (info, _("using multiple gp values"), (char *) NULL,
-		     output_bfd, (asection *) NULL, (bfd_vma) 0);
-		}
-	      *cur_got_tail = NULL;
-	      alpha_elf_tdata(cur_got_obj)->got_link_next = got_list;
-	      got_list = cur_got_obj;
-	      cur_got_obj = i;
-	    }
+	    alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
+	  cur_got_obj = this_got;
+	}
+
+      /* Strange degenerate case of no got references.  */
+      if (got_list == NULL)
+	return true;
+
+      alpha_elf_hash_table (info)->got_list = got_list;
+
+      /* Force got offsets to be recalculated.  */
+      something_changed = 1;
+    }
+
+  cur_got_obj = got_list;
+  i = alpha_elf_tdata(cur_got_obj)->got_link_next;
+  while (i != NULL)
+    {
+      if (elf64_alpha_can_merge_gots (cur_got_obj, i))
+	{
+	  elf64_alpha_merge_gots (cur_got_obj, i);
+	  i = alpha_elf_tdata(i)->got_link_next;
+	  alpha_elf_tdata(cur_got_obj)->got_link_next = i;
+	  something_changed = 1;
 	}
       else
 	{
-	  ++ngots;
 	  cur_got_obj = i;
+	  i = alpha_elf_tdata(i)->got_link_next;
 	}
-      cur_got_tail = &alpha_elf_tdata(i)->in_got_link_next;
     }
 
-  if (cur_got_obj)
-    alpha_elf_tdata (cur_got_obj)->got_link_next = got_list;
-  alpha_elf_hash_table (info)->got_list = cur_got_obj;
-
-  /* Once the gots have been merged, fill in the got offsets for everything
-     therein.  */
-  elf64_alpha_calc_got_offsets (info);
+  /* Once the gots have been merged, fill in the got offsets for
+     everything therein.  */
+  if (1 || something_changed)
+    elf64_alpha_calc_got_offsets (info);
 
   return true;
 }
@@ -3108,39 +3138,31 @@ elf64_alpha_calc_dynrel_sizes (h, info)
 
   /* If the symbol is dynamic, we'll need all the relocations in their
      natural form.  If it has been forced local, we'll need the same 
-     number of RELATIVE relocations.  */
-  if (alpha_elf_dynamic_symbol_p (&h->root, info)
-      || (info->shared && h->root.dynindx == -1))
-    {
-      struct alpha_elf_reloc_entry *relent;
+     number of RELATIVE relocations. 
+     Except, don't add a .got reloc if we're not using a .plt entry.  */
 
-      for (relent = h->reloc_entries; relent; relent = relent->next)
-	{
-	  relent->srel->_raw_size +=
-	    sizeof (Elf64_External_Rela) * relent->count;
-	}
+  if ((alpha_elf_dynamic_symbol_p (&h->root, info)
+       || info->shared)
+      && h->root.plt.offset == MINUS_ONE)
+    {
+      bfd *dynobj = elf_hash_table(info)->dynobj;
+      struct alpha_elf_got_entry *gotent;
+      bfd_size_type count = 0;
+      asection *srel;
 
-      /* Only add a .rela.got entry if we're not using a .plt entry.  */
-      if (h->root.plt_offset == MINUS_ONE)
+      for (gotent = h->got_entries; gotent ; gotent = gotent->next)
+	count++;
+      if (count > 0)
 	{
-	  bfd *dynobj = elf_hash_table(info)->dynobj;
-	  struct alpha_elf_got_entry *gotent;
-	  bfd_size_type count = 0;
-	  asection *srel;
-
-	  for (gotent = h->got_entries; gotent ; gotent = gotent->next)
-	    count++;
-	  if (count > 0)
-	    {
-	      srel = bfd_get_section_by_name (dynobj, ".rela.got");
-	      BFD_ASSERT (srel != NULL);
-	      srel->_raw_size += sizeof (Elf64_External_Rela) * count;
-	    }
+	  srel = bfd_get_section_by_name (dynobj, ".rela.got");
+	  BFD_ASSERT (srel != NULL);
+	  srel->_raw_size += sizeof (Elf64_External_Rela) * count;
 	}
     }
-  /* Otherwise, shared objects require RELATIVE relocs for all REFQUAD
+
+  /* Shared objects require at least RELATIVE relocs for all REFQUAD
      and REFLONG relocations.  */
-  else if (info->shared)
+  if (info->shared)
     {
       struct alpha_elf_reloc_entry *relent;
 
@@ -3581,7 +3603,8 @@ elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
 		    /* If the symbol has been forced local, output a
 		       RELATIVE reloc, otherwise it will be handled in
 		       finish_dynamic_symbol.  */
-		    if (info->shared && h->root.dynindx == -1)
+		    if (info->shared
+			&& !alpha_elf_dynamic_symbol_p (&h->root, info))
 		      {
 			Elf_Internal_Rela outrel;
 
@@ -3794,7 +3817,7 @@ elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
 {
   bfd *dynobj = elf_hash_table(info)->dynobj;
 
-  if (h->plt_offset != MINUS_ONE)
+  if (h->plt.offset != MINUS_ONE)
     {
       /* Fill in the .plt entry for this symbol.  */
       asection *splt, *sgot, *srel;
@@ -3822,21 +3845,21 @@ elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
 		  + gotent->got_offset);
       plt_addr = (splt->output_section->vma
 		  + splt->output_offset
-		  + h->plt_offset);
+		  + h->plt.offset);
 
-      plt_index = (h->plt_offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
+      plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
 
       /* Fill in the entry in the procedure linkage table.  */
       {
 	unsigned insn1, insn2, insn3;
 
-	insn1 = PLT_ENTRY_WORD1 | ((-(h->plt_offset + 4) >> 2) & 0x1fffff);
+	insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
 	insn2 = PLT_ENTRY_WORD2;
 	insn3 = PLT_ENTRY_WORD3;
 
-	bfd_put_32 (output_bfd, insn1, splt->contents + h->plt_offset);
-	bfd_put_32 (output_bfd, insn2, splt->contents + h->plt_offset + 4);
-	bfd_put_32 (output_bfd, insn3, splt->contents + h->plt_offset + 8);
+	bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
+	bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
+	bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
       }
 
       /* Fill in the entry in the .rela.plt section.  */
@@ -4053,6 +4076,15 @@ elf64_alpha_final_link (abfd, info)
   HDRR *symhdr = &debug.symbolic_header;
   PTR mdebug_handle = NULL;
 
+#if 0
+	      if (++ngots == 2)
+		{
+		  (*info->callbacks->warning)
+		    (info, _("using multiple gp values"), (char *) NULL,
+		     output_bfd, (asection *) NULL, (bfd_vma) 0);
+		}
+#endif
+
   /* Go through the sections and collect the .reginfo and .mdebug
      information.  */
   reginfo_sec = NULL;
@@ -4764,5 +4796,7 @@ elf64_alpha_ecoff_debug_swap =
 #define elf_backend_want_got_plt 0
 #define elf_backend_plt_readonly 0
 #define elf_backend_want_plt_sym 1
+#define elf_backend_got_header_size 0
+#define elf_backend_plt_header_size PLT_HEADER_SIZE
 
 #include "elf64-target.h"