commit a345bc8d317a159e3e887632d80c5a8282d34f07

Author: Alan Modra <amodra@gmail.com>

Date:   Fri Nov 1 19:24:20 2013 +1030

    PowerPC64 ELFv2 symbols defined in plt

    In a non-pic executable, ELFv2 like other targets, needs to emit a plt

    entry even for non-call references to functions defined in shared

    libraries, and define the function on the plt code.

    	* elf64-ppc.c (ppc64_elf_copy_indirect_symbol): Copy

    	pointer_equality_needed flag.

    	(ppc64_elf_check_relocs): For ELFv2 arrange to emit plt

    	entries for references to functions in shared libraries on

    	non-call relocs.

    	(readonly_dynrelocs): Split into function of the same name and..

    	(maybe_set_textrel): ..this new function.  Update call.

    	(ppc64_elf_adjust_dynamic_symbol): Don't emit dynrelocs for

    	ELFv2 in most cases if we have a plt entry.  Use new

    	readonly_relocs.

    	(allocate_dynrelocs): For ELFv2, don't allocate dynreloc space

    	for ifunc in static executables.

    	(size_global_entry_stubs): New function.

    	(ppc64_elf_size_dynamic_sections): Call size_global_entry_stubs.

    	Save end of glink branch table.

    	(ppc64_elf_hash_symbol): New function.

    	(build_global_entry_stubs): New function.

    	(ppc64_elf_build_stubs): Call build_global_entry_stubs.  Adjust

    	glink sizing.

    	(ppc64_elf_relocate_section): Tidy plt16/32/64 reloc code.

    	(ppc64_elf_finish_dynamic_symbol): For ELFv2, adjust symbols

    	defined on plt code.

Index: gdb-7.6.1/bfd/elf64-ppc.c

===================================================================

--- gdb-7.6.1.orig/bfd/elf64-ppc.c

+++ gdb-7.6.1/bfd/elf64-ppc.c

@@ -109,6 +109,7 @@ static bfd_vma opd_entry_value

 #define elf_backend_maybe_function_sym	      ppc64_elf_maybe_function_sym

 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust

 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections

+#define elf_backend_hash_symbol		      ppc64_elf_hash_symbol

 #define elf_backend_init_index_section	      _bfd_elf_init_2_index_sections

 #define elf_backend_action_discarded	      ppc64_elf_action_discarded

 #define elf_backend_relocate_section	      ppc64_elf_relocate_section

@@ -174,6 +175,9 @@ static bfd_vma opd_entry_value

 #define LD_R2_0R1	0xe8410000	/* ld    %r2,0(%r1)      */

+#define ADDIS_R12_R12	0x3d8c0000	/* addis %r12,%r12,xxx@ha */

+#define LD_R12_0R12	0xe98c0000	/* ld    %r12,xxx@l(%r12) */

+

 /* glink call stub instructions.  We enter with the index in R0.  */

 #define GLINK_CALL_STUB_SIZE (16*4)

 					/* 0:				*/

@@ -4502,6 +4506,7 @@ ppc64_elf_copy_indirect_symbol (struct b

   edir->elf.ref_regular |= eind->elf.ref_regular;

   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;

   edir->elf.needs_plt |= eind->elf.needs_plt;

+  edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;

   /* Copy over any dynamic relocs we may have on the indirect sym.  */

   if (eind->dyn_relocs != NULL)

@@ -5219,6 +5224,14 @@ ppc64_elf_check_relocs (bfd *abfd, struc

 	    if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,

 					rel->r_addend, tls_type))

 	      return FALSE;

+

+	  /* We may also need a plt entry if the symbol turns out to be

+	     an ifunc.  */

+	  if (h != NULL && !info->shared && abiversion (abfd) == 2)

+	    {

+	      if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))

+		return FALSE;

+	    }

 	  break;

 	case R_PPC64_PLT16_HA:

@@ -5467,12 +5480,6 @@ ppc64_elf_check_relocs (bfd *abfd, struc

 	    }

 	  /* Fall through.  */

-	case R_PPC64_REL30:

-	case R_PPC64_REL32:

-	case R_PPC64_REL64:

-	case R_PPC64_ADDR14:

-	case R_PPC64_ADDR14_BRNTAKEN:

-	case R_PPC64_ADDR14_BRTAKEN:

 	case R_PPC64_ADDR16:

 	case R_PPC64_ADDR16_DS:

 	case R_PPC64_ADDR16_HA:

@@ -5483,6 +5490,23 @@ ppc64_elf_check_relocs (bfd *abfd, struc

 	case R_PPC64_ADDR16_HIGHESTA:

 	case R_PPC64_ADDR16_LO:

 	case R_PPC64_ADDR16_LO_DS:

+	  if (h != NULL && !info->shared && abiversion (abfd) == 2

+	      && rel->r_addend == 0)

+	    {

+	      /* We may need a .plt entry if this reloc refers to a

+		 function in a shared lib.  */

+	      if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))

+		return FALSE;

+	      h->pointer_equality_needed = 1;

+	    }

+	  /* Fall through.  */

+

+	case R_PPC64_REL30:

+	case R_PPC64_REL32:

+	case R_PPC64_REL64:

+	case R_PPC64_ADDR14:

+	case R_PPC64_ADDR14_BRNTAKEN:

+	case R_PPC64_ADDR14_BRTAKEN:

 	case R_PPC64_ADDR24:

 	case R_PPC64_ADDR32:

 	case R_PPC64_UADDR16:

@@ -6667,6 +6691,25 @@ ppc64_elf_func_desc_adjust (bfd *obfd AT

   return TRUE;

 }

+/* Return true if we have dynamic relocs that apply to read-only sections.  */

+

+static bfd_boolean

+readonly_dynrelocs (struct elf_link_hash_entry *h)

+{

+  struct ppc_link_hash_entry *eh;

+  struct elf_dyn_relocs *p;

+

+  eh = (struct ppc_link_hash_entry *) h;

+  for (p = eh->dyn_relocs; p != NULL; p = p->next)

+    {

+      asection *s = p->sec->output_section;

+

+      if (s != NULL && (s->flags & SEC_READONLY) != 0)

+	return TRUE;

+    }

+  return FALSE;

+}

+

 /* Adjust a symbol defined by a dynamic object and referenced by a

    regular object.  The current definition is in some section of the

    dynamic object, but we're not including those sections.  We have to

@@ -6704,6 +6747,26 @@ ppc64_elf_adjust_dynamic_symbol (struct

 	  h->plt.plist = NULL;

 	  h->needs_plt = 0;

 	}

+      else if (abiversion (info->output_bfd) == 2)

+	{

+	  /* After adjust_dynamic_symbol, non_got_ref set in the

+	     non-shared case means that we have allocated space in

+	     .dynbss for the symbol and thus dyn_relocs for this

+	     symbol should be discarded.

+	     If we get here we know we are making a PLT entry for this

+	     symbol, and in an executable we'd normally resolve

+	     relocations against this symbol to the PLT entry.  Allow

+	     dynamic relocs if the reference is weak, and the dynamic

+	     relocs will not cause text relocation.  */

+	  if (!h->ref_regular_nonweak

+	      && h->non_got_ref

+	      && h->type != STT_GNU_IFUNC

+	      && !readonly_dynrelocs (h))

+	    h->non_got_ref = 0;

+

+	  /* If making a plt entry, then we don't need copy relocs.  */

+	  return TRUE;

+	}

     }

   else

     h->plt.plist = NULL;

@@ -6738,26 +6801,12 @@ ppc64_elf_adjust_dynamic_symbol (struct

   if (!h->def_dynamic || !h->ref_regular || h->def_regular)

     return TRUE;

-  if (ELIMINATE_COPY_RELOCS)

+  /* 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 (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))

     {

-      struct ppc_link_hash_entry * eh;

-      struct elf_dyn_relocs *p;

-

-      eh = (struct ppc_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;

-	}

+      h->non_got_ref = 0;

+      return TRUE;

     }

   if (h->plt.plist != NULL)

@@ -9167,7 +9216,8 @@ allocate_dynrelocs (struct elf_link_hash

   if (eh->dyn_relocs == NULL

       || (!htab->elf.dynamic_sections_created

-	  && h->type != STT_GNU_IFUNC))

+	  && (h->type != STT_GNU_IFUNC

+	      || !htab->opd_abi)))

     return TRUE;

   /* In the shared -Bsymbolic case, discard space allocated for

@@ -9263,28 +9313,59 @@ allocate_dynrelocs (struct elf_link_hash

   return TRUE;

 }

-/* Find any dynamic relocs that apply to read-only sections.  */

+/* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections

+   to set up space for global entry stubs.  These are put in glink,

+   after the branch table.  */

 static bfd_boolean

-readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)

+size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)

 {

-  struct ppc_link_hash_entry *eh;

-  struct elf_dyn_relocs *p;

+  struct bfd_link_info *info;

+  struct ppc_link_hash_table *htab;

+  struct plt_entry *pent;

+  asection *s;

-  eh = (struct ppc_link_hash_entry *) h;

-  for (p = eh->dyn_relocs; p != NULL; p = p->next)

-    {

-      asection *s = p->sec->output_section;

+  if (h->root.type == bfd_link_hash_indirect)

+    return TRUE;

-      if (s != NULL && (s->flags & SEC_READONLY) != 0)

-	{

-	  struct bfd_link_info *info = inf;

+  if (!h->pointer_equality_needed)

+    return TRUE;

-	  info->flags |= DF_TEXTREL;

+  if (h->def_regular)

+    return TRUE;

-	  /* Not an error, just cut short the traversal.  */

-	  return FALSE;

-	}

+  info = inf;

+  htab = ppc_hash_table (info);

+  if (htab == NULL)

+    return FALSE;

+

+  s = htab->glink;

+  for (pent = h->plt.plist; pent != NULL; pent = pent->next)

+    if (pent->plt.offset != (bfd_vma) -1

+	&& pent->addend == 0)

+      {

+	s->size = (s->size + 15) & -16;

+	s->size += 16;

+	break;

+      }

+  return TRUE;

+}

+

+/* Set DF_TEXTREL if we find any dynamic relocs that apply to

+   read-only sections.  */

+

+static bfd_boolean

+maybe_set_textrel (struct elf_link_hash_entry *h, void *info)

+{

+  if (h->root.type == bfd_link_hash_indirect)

+    return TRUE;

+

+  if (readonly_dynrelocs (h))

+    {

+      ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;

+

+      /* Not an error, just cut short the traversal.  */

+      return FALSE;

     }

   return TRUE;

 }

@@ -9435,6 +9516,12 @@ ppc64_elf_size_dynamic_sections (bfd *ou

   /* Allocate global sym .plt and .got entries, and space for global

      sym dynamic relocs.  */

   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);

+  /* Stash the end of glink branch table.  */

+  if (htab->glink != NULL)

+    htab->glink->rawsize = htab->glink->size;

+

+  if (!htab->opd_abi && !info->shared)

+    elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);

   first_tlsld = NULL;

   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)

@@ -9632,7 +9719,7 @@ ppc64_elf_size_dynamic_sections (bfd *ou

 	  /* If any dynamic relocs apply to a read-only section,

 	     then we need a DT_TEXTREL entry.  */

 	  if ((info->flags & DF_TEXTREL) == 0)

-	    elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);

+	    elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);

 	  if ((info->flags & DF_TEXTREL) != 0)

 	    {

@@ -9646,6 +9733,19 @@ ppc64_elf_size_dynamic_sections (bfd *ou

   return TRUE;

 }

+/* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */

+

+static bfd_boolean

+ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)

+{

+  if (h->plt.plist != NULL

+      && !h->def_regular

+      && !h->pointer_equality_needed)

+    return FALSE;

+

+  return _bfd_elf_hash_symbol (h);

+}

+

 /* Determine the type of stub needed, if any, for a call.  */

 static inline enum ppc_stub_type

@@ -12049,6 +12149,79 @@ ppc64_elf_toc (bfd *obfd)

   return TOCstart;

 }

+/* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to

+   write out any global entry stubs.  */

+

+static bfd_boolean

+build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)

+{

+  struct bfd_link_info *info;

+  struct ppc_link_hash_table *htab;

+  struct plt_entry *pent;

+  asection *s;

+

+  if (h->root.type == bfd_link_hash_indirect)

+    return TRUE;

+

+  if (!h->pointer_equality_needed)

+    return TRUE;

+

+  if (h->def_regular)

+    return TRUE;

+

+  info = inf;

+  htab = ppc_hash_table (info);

+  if (htab == NULL)

+    return FALSE;

+

+  s = htab->glink;

+  for (pent = h->plt.plist; pent != NULL; pent = pent->next)

+    if (pent->plt.offset != (bfd_vma) -1

+	&& pent->addend == 0)

+      {

+	bfd_byte *p;

+	asection *plt;

+	bfd_vma off;

+

+	/* For ELFv2, if this symbol is not defined in a regular file

+	   and we are not generating a shared library or pie, then we

+	   need to define the symbol in the executable on a call stub.

+	   This is to avoid text relocations.  */

+	h->root.u.def.section = s;

+	h->root.u.def.value = s->size;

+	s->size += 16;

+	p = s->contents + h->root.u.def.value;

+	plt = htab->plt;

+	if (!htab->elf.dynamic_sections_created

+	    || h->dynindx == -1)

+	  plt = htab->iplt;

+	off = pent->plt.offset + plt->output_offset + plt->output_section->vma;

+	off -= h->root.u.def.value + s->output_offset + s->output_section->vma;

+

+	if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)

+	  {

+	    info->callbacks->einfo

+	      (_("%P: linkage table error against `%T'\n"),

+	       h->root.root.string);

+	    bfd_set_error (bfd_error_bad_value);

+	    htab->stub_error = TRUE;

+	  }

+

+	if (PPC_HA (off) != 0)

+	  {

+	    bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);

+	    p += 4;

+	  }

+	bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);

+	p += 4;

+	bfd_put_32 (s->owner, MTCTR_R12, p);

+	p += 4;

+	bfd_put_32 (s->owner, BCTR, p);

+	break;

+      }

+  return TRUE;

+}

+

 /* Build all the stubs associated with the current output file.

    The stubs are kept in a hash table attached to the main linker

    hash table.  This function is called via gldelf64ppc_finish.  */

@@ -12184,7 +12357,7 @@ ppc64_elf_build_stubs (bfd_boolean emit_

       /* Build the .glink lazy link call stubs.  */

       indx = 0;

-      while (p < htab->glink->contents + htab->glink->size)

+      while (p < htab->glink->contents + htab->glink->rawsize)

 	{

 	  if (htab->opd_abi)

 	    {

@@ -12207,7 +12380,13 @@ ppc64_elf_build_stubs (bfd_boolean emit_

 	  indx++;

 	  p += 4;

 	}

-      htab->glink->rawsize = p - htab->glink->contents;

+

+      /* Build .glink global entry stubs.  */

+      if (htab->glink->size > htab->glink->rawsize)

+	{

+	  htab->glink->size = (htab->glink->rawsize + 15) & -16;

+	  elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);

+	}

     }

   if (htab->brlt->size != 0)

@@ -12311,7 +12490,7 @@ ppc64_elf_build_stubs (bfd_boolean emit_

 	  bfd_put_32 (htab->elf.dynobj, val, p);

 	  p += 4;

 	  /* .glink size.  */

-	  bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);

+	  bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);

 	  p += 4;

 	  /* Augmentation.  */

 	  p += 1;

@@ -12361,7 +12540,6 @@ ppc64_elf_build_stubs (bfd_boolean emit_

       }

   if (stub_sec != NULL

-      || htab->glink->rawsize != htab->glink->size

       || (htab->glink_eh_frame != NULL

 	  && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))

     {

@@ -13588,13 +13766,14 @@ ppc64_elf_relocate_section (bfd *output_

 	    {

 	      struct plt_entry *ent;

 	      for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)

-		if (ent->addend == orig_rel.r_addend

-		    && ent->plt.offset != (bfd_vma) -1)

+		if (ent->plt.offset != (bfd_vma) -1

+		    && ent->addend == orig_rel.r_addend)

 		  {

 		    relocation = (htab->plt->output_section->vma

 				  + htab->plt->output_offset

 				  + ent->plt.offset);

 		    unresolved_reloc = FALSE;

+		    break;

 		  }

 	    }

 	  break;

@@ -14297,6 +14476,30 @@ ppc64_elf_finish_dynamic_symbol (bfd *ou

 		      / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));

 	  }

 	bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);

+

+	if (!htab->opd_abi)

+	  {

+	    if (!h->def_regular)

+	      {

+		/* Mark the symbol as undefined, rather than as

+		   defined in glink.  Leave the value if there were

+		   any relocations where pointer equality matters

+		   (this is a clue for the dynamic linker, to make

+		   function pointer comparisons work between an

+		   application and shared library), otherwise set it

+		   to zero.  */

+		sym->st_shndx = SHN_UNDEF;

+		if (!h->pointer_equality_needed)

+		  sym->st_value = 0;

+		else if (!h->ref_regular_nonweak)

+		  {

+		    /* This breaks function pointer comparisons, but

+		       that is better than breaking tests for a NULL

+		       function pointer.  */

+		    sym->st_value = 0;

+		  }

+	      }

+	  }

       }

   if (h->needs_copy)