Add support for linking against shared libraries

2 files changed, 338 insertions, 67 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 9a855ab..3210424 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,5 +1,17 @@
 Thu Apr 25 13:25:12 1996  Michael Meissner  <meissner@tiktok.cygnus.com>
 
+	* elf32-ppc.c (ppc_elf_create_linker_section): Add PLT case.
+	(ppc_elf_additional_program_headers): If .interp section, bump #
+	of program headers by 1.
+	(ppc_elf_adjust_dynamic_symbol): Flesh out support.
+	(ppc_elf_size_dynamic_sections): Add support for .plt section.
+	(ppc_elf_check_relocs): Print out filename in debug code.  Enable
+	PLT support.
+	(ppc_elf_finish_dynamic_symbol): Add support for PLT's, beef up
+	debug output.
+	(ppc_elf_relocate_section): If the output section isn't defined,
+	don't abort, just give an error message.
+
 	* elflink.c (_bfd_elf_create_dynamic_sections): If the section
 	being created is .sdata or .sdata2, don't make the symbol dynamic.
 
diff --git a/bfd/elf32-ppc.c b/bfd/elf32-ppc.c
index 8b68031..895588b 100644
--- a/bfd/elf32-ppc.c
+++ b/bfd/elf32-ppc.c
@@ -108,6 +108,9 @@ static boolean ppc_elf_set_private_flags PARAMS ((bfd *, flagword));
 static boolean ppc_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
 static boolean ppc_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
 
+static int ppc_elf_additional_program_headers PARAMS ((bfd *));
+static boolean ppc_elf_modify_segment_map PARAMS ((bfd *));
+
 static boolean ppc_elf_section_from_shdr PARAMS ((bfd *,
 						  Elf32_Internal_Shdr *,
 						  char *));
@@ -162,6 +165,12 @@ static boolean ppc_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_i
 
 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 
+/* The size in bytes of an entry in the procedure linkage table, and of the initial size
+   of the plt reserved for the dynamic linker.  */
+
+#define PLT_ENTRY_SIZE 12
+#define PLT_INITIAL_ENTRY_SIZE 72
+
 
 static reloc_howto_type *ppc_elf_howto_table[ (int)R_PPC_max ];
 
@@ -1212,6 +1221,8 @@ ppc_elf_fake_sections (abfd, shdr, asect)
 
   if ((asect->flags & SEC_SORT_ENTRIES) != 0)
     shdr->sh_type = SHT_ORDERED;
+
+  return true;
 }
 
 
@@ -1261,6 +1272,16 @@ ppc_elf_create_linker_section (abfd, info, which)
 	  defaults.sym_offset	   = 4;
 	  break;
 
+	case LINKER_SECTION_PLT:	/* .plt section */
+	  defaults.name		   = ".plt";
+	  defaults.rel_name	   = ".rela.plt";
+	  defaults.sym_name	   = (char *)0;
+	  defaults.max_hole_offset = 0;
+	  defaults.hole_size	   = 0;
+	  defaults.sym_offset	   = 0;
+	  defaults.flags	  &= ~SEC_LOAD;
+	  break;
+
 	case LINKER_SECTION_SDATA:	/* .sdata/.sbss section */
 	  defaults.name		  = ".sdata";
 	  defaults.rel_name	  = ".rela.sdata";
@@ -1275,6 +1296,7 @@ ppc_elf_create_linker_section (abfd, info, which)
 	  defaults.bss_name	  = ".sbss2";
 	  defaults.sym_name	  = "_SDA2_BASE_";
 	  defaults.sym_offset	  = 32768;
+	  defaults.flags	 |= SEC_READONLY;
 	  break;
 	}
 
@@ -1285,6 +1307,42 @@ ppc_elf_create_linker_section (abfd, info, which)
 }
 
 
+/* If we have a non-zero sized .sbss2 or .PPC.EMB.sbss0 sections, we need to bump up
+   the number of section headers.  */
+
+static int
+ppc_elf_additional_program_headers (abfd)
+     bfd *abfd;
+{
+  asection *s;
+  int ret;
+
+  ret = 0;
+
+  s = bfd_get_section_by_name (abfd, ".interp");
+  if (s != NULL)
+    ++ret;
+
+  s = bfd_get_section_by_name (abfd, ".sbss2");
+  if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
+    ++ret;
+
+  s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
+  if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
+    ++ret;
+
+  return ret;
+}
+
+/* Modify the segment map if needed */
+
+static boolean
+ppc_elf_modify_segment_map (abfd)
+     bfd *abfd;
+{
+  return true;
+}
+
 /* Adjust a symbol defined by a dynamic object and referenced by a
    regular object.  The current definition is in some section of the
    dynamic object, but we're not including those sections.  We have to
@@ -1296,9 +1354,167 @@ ppc_elf_adjust_dynamic_symbol (info, h)
      struct bfd_link_info *info;
      struct elf_link_hash_entry *h;
 {
+  bfd *dynobj = elf_hash_table (info)->dynobj;
+  asection *s;
+  unsigned int power_of_two;
+  bfd_vma plt_offset;
+
 #ifdef DEBUG
-  fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called\n");
+  fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", h->root.root.string);
 #endif
+
+  /* Make sure we know what is going on here.  */
+  BFD_ASSERT (dynobj != NULL
+	      && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
+		  || h->weakdef != NULL
+		  || ((h->elf_link_hash_flags
+		       & ELF_LINK_HASH_DEF_DYNAMIC) != 0
+		      && (h->elf_link_hash_flags
+			  & ELF_LINK_HASH_REF_REGULAR) != 0
+		      && (h->elf_link_hash_flags
+			  & ELF_LINK_HASH_DEF_REGULAR) == 0)));
+
+
+  /* If this is a function, put it in the procedure linkage table.  We
+     will fill in the contents of the procedure linkage table later,
+     when we know the address of the .got section.  */
+  if (h->type == STT_FUNC
+      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
+    {
+      if (! info->shared
+	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
+	  && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
+	{
+	  /* This case can occur if we saw a PLT32 reloc in an input
+             file, but the symbol was never referred to by a dynamic
+             object.  In such a case, we don't actually need to build
+             a procedure linkage table, and we can just do a PC32
+             reloc instead.  */
+	  BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
+	  return true;
+	}
+
+      /* Make sure this symbol is output as a dynamic symbol.  */
+      if (h->dynindx == -1)
+	{
+	  if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+	    return false;
+	}
+
+      s = bfd_get_section_by_name (dynobj, ".plt");
+      BFD_ASSERT (s != NULL);
+
+      /* If this is the first .plt entry, make room for the special
+	 first entry.  */
+      if (s->_raw_size == 0)
+	s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
+
+      /* The PowerPC PLT is actually composed of two parts, the first part
+	 is 2 words (for a load and a jump), and then there is a remaining
+	 word available at the end.  */
+      plt_offset = (PLT_INITIAL_ENTRY_SIZE
+		    + 8 * ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE));
+
+      /* If this symbol is not defined in a regular file, and we are
+	 not generating a shared library, then set the symbol to this
+	 location in the .plt.  This is required to make function
+	 pointers compare as equal between the normal executable and
+	 the shared library.  */
+      if (! info->shared
+	  && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+	{
+	  h->root.u.def.section = s;
+	  h->root.u.def.value = plt_offset;
+	}
+
+      h->plt_offset = plt_offset;
+
+      /* Make room for this entry.  */
+      s->_raw_size += PLT_ENTRY_SIZE;
+
+      /* We also need to make an entry in the .rela.plt section.  */
+
+      s = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (s != NULL);
+      s->_raw_size += sizeof (Elf32_External_Rela);
+
+      return true;
+    }
+
+  /* If this is a weak symbol, and there is a real definition, the
+     processor independent code will have arranged for us to see the
+     real definition first, and we can just use the same value.  */
+  if (h->weakdef != NULL)
+    {
+      BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
+		  || h->weakdef->root.type == bfd_link_hash_defweak);
+      h->root.u.def.section = h->weakdef->root.u.def.section;
+      h->root.u.def.value = h->weakdef->root.u.def.value;
+      return true;
+    }
+
+  /* This is a reference to a symbol defined by a dynamic object which
+     is not a function.  */
+
+  /* If we are creating a shared library, we must presume that the
+     only references to the symbol are via the global offset table.
+     For such cases we need not do anything here; the relocations will
+     be handled correctly by relocate_section.  */
+  if (info->shared)
+    return true;
+
+  /* We must allocate the symbol in our .dynbss section, which will
+     become part of the .bss section of the executable.  There will be
+     an entry for this symbol in the .dynsym section.  The dynamic
+     object will contain position independent code, so all references
+     from the dynamic object to this symbol will go through the global
+     offset table.  The dynamic linker will use the .dynsym entry to
+     determine the address it must put in the global offset table, so
+     both the dynamic object and the regular object will refer to the
+     same memory location for the variable.  */
+
+  s = bfd_get_section_by_name (dynobj, ".dynbss");
+  BFD_ASSERT (s != NULL);
+
+  /* If the symbol is currently defined in the .bss section of the
+     dynamic object, then it is OK to simply initialize it to zero.
+     If the symbol is in some other section, we must generate a
+     R_386_COPY reloc to tell the dynamic linker to copy the initial
+     value out of the dynamic object and into the runtime process
+     image.  We need to remember the offset into the .rela.bss section
+     we are going to use.  */
+  if ((h->root.u.def.section->flags & SEC_LOAD) != 0)
+    {
+      asection *srel;
+
+      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
+      BFD_ASSERT (srel != NULL);
+      srel->_raw_size += sizeof (Elf32_External_Rel);
+      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
+    }
+
+  /* We need to figure out the alignment required for this symbol.  I
+     have no idea how ELF linkers handle this.  */
+  power_of_two = bfd_log2 (h->size);
+  if (power_of_two > 3)
+    power_of_two = 3;
+
+  /* Apply the required alignment.  */
+  s->_raw_size = BFD_ALIGN (s->_raw_size,
+			    (bfd_size_type) (1 << power_of_two));
+  if (power_of_two > bfd_get_section_alignment (dynobj, s))
+    {
+      if (! bfd_set_section_alignment (dynobj, s, power_of_two))
+	return false;
+    }
+
+  /* Define the symbol as being at this point in the section.  */
+  h->root.u.def.section = s;
+  h->root.u.def.value = s->_raw_size;
+
+  /* Increment the section size to make room for the symbol.  */
+  s->_raw_size += h->size;
+
   return true;
 }
 
@@ -1333,8 +1549,9 @@ ppc_elf_size_dynamic_sections (output_bfd, info)
 {
   bfd *dynobj;
   asection *s;
+  boolean plt;
+  boolean relocs;
   boolean reltext;
-  boolean relplt;
 
 #ifdef DEBUG
   fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
@@ -1381,8 +1598,9 @@ ppc_elf_size_dynamic_sections (output_bfd, info)
   /* The check_relocs and adjust_dynamic_symbol entry points have
      determined the sizes of the various dynamic sections.  Allocate
      memory for them.  */
+  plt = false;
+  relocs = false;
   reltext = false;
-  relplt = false;
   for (s = dynobj->sections; s != NULL; s = s->next)
     {
       const char *name;
@@ -1397,15 +1615,28 @@ ppc_elf_size_dynamic_sections (output_bfd, info)
 
       strip = false;
 
-#if 0
-      if (strncmp (name, ".rela", 5) == 0)
+      if (strcmp (name, ".plt") == 0)
+	{
+	  if (s->_raw_size == 0)
+	    {
+	      /* Strip this section if we don't need it; see the
+                 comment below.  */
+	      strip = true;
+	    }
+	  else
+	    {
+	      /* Remember whether there is a PLT.  */
+	      plt = true;
+	    }
+	}
+      else if (strncmp (name, ".rela", 5) == 0)
 	{
 	  if (s->_raw_size == 0)
 	    {
 	      /* If we don't need this section, strip it from the
-		 output file.  This is to handle .rela.bss and
-		 .rel.plt.  We must create it in
-		 create_dynamic_sections, because it must be created
+		 output file.  This is mostly to handle .rela.bss and
+		 .rela.plt.  We must create both sections in
+		 create_dynamic_sections, because they must be created
 		 before the linker maps input sections to output
 		 sections.  The linker does that before
 		 adjust_dynamic_symbol is called, and it is that
@@ -1417,29 +1648,31 @@ ppc_elf_size_dynamic_sections (output_bfd, info)
 	    {
 	      asection *target;
 
-	      /* If this relocation section applies to a read only
-		 section, then we probably need a DT_TEXTREL entry.  */
-	      target = bfd_get_section_by_name (output_bfd, name + 5);
-	      if (target != NULL
-		  && (target->flags & SEC_READONLY) != 0)
-		reltext = true;
-
-	      if (strcmp (name, ".rela.plt") == 0)
-		relplt = true;
+	      /* Remember whether there are any reloc sections other
+                 than .rel.plt.  */
+	      if (strcmp (name, ".rela.plt") != 0)
+		{
+		  relocs = true;
+
+		  /* If this relocation section applies to a read only
+		     section, then we probably need a DT_TEXTREL
+		     entry.  The entries in the .rel.plt section
+		     really apply to the .got section, which we
+		     created ourselves and so know is not readonly.  */
+		  target = bfd_get_section_by_name (output_bfd, name + 4);
+		  if (target != NULL
+		      && (target->flags & SEC_READONLY) != 0)
+		    reltext = true;
+		}
 
 	      /* We use the reloc_count field as a counter if we need
 		 to copy relocs into the output file.  */
 	      s->reloc_count = 0;
 	    }
 	}
-      else
-#endif
-	if (strcmp (name, ".plt") != 0
-	    && strcmp (name, ".got") != 0
-	    && strcmp (name, ".sdata") != 0
-	    && strcmp (name, ".sdata2") != 0
-	    && strcmp (name, ".rela.sdata") != 0
-	    && strcmp (name, ".rela.sdata2") != 0)
+      else if (strcmp (name, ".got") != 0
+	       && strcmp (name, ".sdata") != 0
+	       && strcmp (name, ".sdata2") != 0)
 	{
 	  /* It's not one of our sections, so don't allocate space.  */
 	  continue;
@@ -1478,22 +1711,23 @@ ppc_elf_size_dynamic_sections (output_bfd, info)
 	    return false;
 	}
 
-      if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0))
-	return false;
-
-      if (relplt)
+      if (plt)
 	{
-	  if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
-	      || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
+	  if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
+	      || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
+	      || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
 	      || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
 	    return false;
 	}
 
-      if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
-	  || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
-	  || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
-					    sizeof (Elf32_External_Rela)))
-	return false;
+      if (relocs)
+	{
+	  if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
+	      || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, DT_RELA)
+	      || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
+						sizeof (Elf32_External_Rela)))
+	    return false;
+	}
 
       if (reltext)
 	{
@@ -1546,6 +1780,7 @@ ppc_elf_check_relocs (abfd, info, sec, relocs)
   const Elf_Internal_Rela *rel;
   const Elf_Internal_Rela *rel_end;
   elf_linker_section_t *got;
+  elf_linker_section_t *plt;
   elf_linker_section_t *sdata;
   elf_linker_section_t *sdata2;
   asection *sreloc;
@@ -1554,8 +1789,9 @@ ppc_elf_check_relocs (abfd, info, sec, relocs)
     return true;
 
 #ifdef DEBUG
-  fprintf (stderr, "ppc_elf_check_relocs called for section %s\n",
-	   bfd_get_section_name (abfd, sec));
+  fprintf (stderr, "ppc_elf_check_relocs called for section %s in %s\n",
+	   bfd_get_section_name (abfd, sec),
+	   bfd_get_filename (abfd));
 #endif
 
   /* Create the linker generated sections all the time so that the special
@@ -1567,6 +1803,15 @@ ppc_elf_check_relocs (abfd, info, sec, relocs)
 	return false;
     }
 
+#if 0
+  if ((plt = elf_linker_section (abfd, LINKER_SECTION_PLT)) == NULL)
+    {
+      plt = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_PLT);
+      if (!plt)
+	return false;
+    }
+#endif
+
   if ((sdata = elf_linker_section (abfd, LINKER_SECTION_SDATA)) == NULL)
     {
       sdata = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
@@ -1644,7 +1889,6 @@ ppc_elf_check_relocs (abfd, info, sec, relocs)
 
 	  break;
 
-#if 0
 	case R_PPC_PLT32:
 	case R_PPC_PLTREL24:
 	case R_PPC_PLT16_LO:
@@ -1677,6 +1921,7 @@ ppc_elf_check_relocs (abfd, info, sec, relocs)
 	  h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 	  break;
 
+#if 0
 	case R_SPARC_PC10:
 	case R_SPARC_PC22:
 	  if (h != NULL
@@ -1766,12 +2011,14 @@ ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
     {
       /* Common symbols less than or equal to -G nn bytes are automatically
 	 put into .sdata.  */
-      bfd *dynobj = elf_hash_table (info)->dynobj;
-      elf_linker_section_t *sdata = elf_linker_section (dynobj, LINKER_SECTION_SDATA);
+      elf_linker_section_t *sdata = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
       if (!sdata->bss_section)
-	sdata->bss_section = bfd_make_section (dynobj, sdata->bss_name);
+	{
+	  sdata->bss_section = bfd_make_section (elf_hash_table (info)->dynobj, sdata->bss_name);
+	  sdata->bss_section->flags = (sdata->bss_section->flags & ~SEC_LOAD) | SEC_IS_COMMON;
+	}
+
       *secp = sdata->bss_section;
-      (*secp)->flags |= SEC_IS_COMMON;
       *valp = sym->st_size;
     }
 
@@ -1792,7 +2039,7 @@ ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
   bfd *dynobj;
 
 #ifdef DEBUG
-  fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s\n", h->root.root.string);
+  fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s", h->root.root.string);
 #endif
 
   dynobj = elf_hash_table (info)->dynobj;
@@ -1804,6 +2051,10 @@ ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
       asection *srela;
       Elf_Internal_Rela rela;
 
+#ifdef DEBUG
+      fprintf (stderr, ", plt_offset = %d", h->plt_offset);
+#endif
+
       /* This symbol has an entry in the procedure linkage table.  Set
          it up.  */
 
@@ -1813,28 +2064,18 @@ ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
       BFD_ASSERT (splt != NULL && srela != NULL);
 
-      /* Fill in the entry in the procedure linkage table.  */
-#if 0
-      bfd_put_32 (output_bfd,
-		  PLT_ENTRY_WORD0 + h->plt_offset,
-		  splt->contents + h->plt_offset);
-      bfd_put_32 (output_bfd,
-		  (PLT_ENTRY_WORD1
-		   + (((- (h->plt_offset + 4)) >> 2) & 0x3fffff)),
-		  splt->contents + h->plt_offset + 4);
-      bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
-		  splt->contents + h->plt_offset + 8);
+      /* We don't need to fill in the .plt.  The solaris dynamic linker will
+	 fill it in.  */
 
       /* Fill in the entry in the .rela.plt section.  */
       rela.r_offset = (splt->output_section->vma
 		       + splt->output_offset
 		       + h->plt_offset);
-      rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
+      rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
       rela.r_addend = 0;
       bfd_elf32_swap_reloca_out (output_bfd, &rela,
 				 ((Elf32_External_Rela *) srela->contents
-				  + h->plt_offset / PLT_ENTRY_SIZE - 4));
-#endif
+				  + ((h->plt_offset - PLT_INITIAL_ENTRY_SIZE) / 8)));
 
       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
 	{
@@ -1851,6 +2092,10 @@ ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
 
       /* This symbols needs a copy reloc.  Set it up.  */
 
+#ifdef DEBUG
+      fprintf (stderr, ", copy");
+#endif
+
       BFD_ASSERT (h->dynindx != -1);
 
       s = bfd_get_section_by_name (h->root.u.def.section->owner,
@@ -1868,6 +2113,10 @@ ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
       ++s->reloc_count;
     }
 
+#ifdef DEBUG
+  fprintf (stderr, "\n");
+#endif
+
   /* Mark some specially defined symbols as absolute.  */
   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
@@ -1915,10 +2164,10 @@ ppc_elf_finish_dynamic_sections (output_bfd, info)
 
 	  switch (dyn.d_tag)
 	    {
-	    case DT_PLTGOT:   name = ".plt"; size = false; break;
-	    case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
+	    case DT_PLTGOT:   name = ".plt";	  size = false; break;
+	    case DT_PLTRELSZ: name = ".rela.plt"; size = true;  break;
 	    case DT_JMPREL:   name = ".rela.plt"; size = false; break;
-	    default:	  name = NULL; size = false; break;
+	    default:	      name = NULL;	  size = false; break;
 	    }
 
 	  if (name != NULL)
@@ -2048,9 +2297,9 @@ ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
   Elf_Internal_Shdr *symtab_hdr		  = &elf_tdata (input_bfd)->symtab_hdr;
   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
   bfd *dynobj				  = elf_hash_table (info)->dynobj;
-  elf_linker_section_t *got		  = elf_linker_section (dynobj, LINKER_SECTION_GOT);
-  elf_linker_section_t *sdata		  = elf_linker_section (dynobj, LINKER_SECTION_SDATA);
-  elf_linker_section_t *sdata2		  = elf_linker_section (dynobj, LINKER_SECTION_SDATA2);
+  elf_linker_section_t *got		  = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_GOT)    : NULL;
+  elf_linker_section_t *sdata		  = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA)  : NULL;
+  elf_linker_section_t *sdata2		  = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA2) : NULL;
   Elf_Internal_Rela *rel		  = relocs;
   Elf_Internal_Rela *relend		  = relocs + input_section->reloc_count;
   boolean ret				  = true;
@@ -2145,9 +2394,17 @@ ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 	      || h->root.type == bfd_link_hash_defweak)
 	    {
 	      sec = h->root.u.def.section;
-	      relocation = (h->root.u.def.value
-			    + sec->output_section->vma
-			    + sec->output_offset);
+	      if (!sec || !sec->output_section)
+		{
+		  (*_bfd_error_handler) ("%s: Section in shared library for symbol %s\n",
+					 bfd_get_filename (input_bfd),
+					 sym_name);
+		  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;
@@ -2510,5 +2767,7 @@ ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 #define elf_backend_finish_dynamic_symbol	ppc_elf_finish_dynamic_symbol
 #define elf_backend_finish_dynamic_sections	ppc_elf_finish_dynamic_sections
 #define elf_backend_fake_sections		ppc_elf_fake_sections
+#define elf_backend_additional_program_headers	ppc_elf_additional_program_headers
+#define elf_backend_modify_segment_map		ppc_elf_modify_segment_map
 
 #include "elf32-target.h"