* elf64-alpha.c (alpha_elf_dynamic_symbol_p): Undef weak symbols
authorRichard Henderson <rth@redhat.com>
Sat, 8 Aug 1998 22:17:16 +0000 (22:17 +0000)
committerRichard Henderson <rth@redhat.com>
Sat, 8 Aug 1998 22:17:16 +0000 (22:17 +0000)
        are always dynamic.
        (elf64_alpha_calc_dynrel_sizes): Allow enough room for RELATIVE
        .got relocs in -Bsymbolic shared objects.

bfd/ChangeLog
bfd/elf64-alpha.c

index 9701b935816fda01f6f017ef5d5c90e625a85bb7..30f5694cb1fac67311fcfa6845121c2edc45c4c0 100644 (file)
@@ -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>
 
index a4aa3aa0ef5f6fb754b7b2ff5308ed5fa22af117..dc9c6ccfa7a15d3f95616bede2894abfb302164e 100644 (file)
@@ -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"