Commit: 7d37558a1c3f7b3b67022872a27b5e4e71c9e2e4 - binutils_gdb (git)

Commit MetaInfo

• Revision: 7d37558a1c3f7b3b67022872a27b5e4e71c9e2e4 (tree)
• Time: 2022-12-08 12:30:02
• Author: Yoshinori Sato <ysato@user...>
• Commiter: Yoshinori Sato

Log Message

wip: bfd rx-fdpic

Signed-off-by: Yoshinori Sato <[e-mail]>

Change Summary

• modified: bfd/bfd-in2.h
• modified: bfd/elf32-rx.c
• modified: bfd/libbfd.h
• modified: bfd/reloc.c
• modified: gas/config/tc-rx.c
• modified: include/elf/rx.h

Incremental Difference

--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -4441,6 +4441,9 @@ number for the SBIC, SBIS, SBI and CBI instructions  */
   BFD_RELOC_RX_GOTOFF,
   BFD_RELOC_RX_PLT,
   BFD_RELOC_RX_GOTPC,
+  BFD_RELOC_RX_GOTFUNCDESC,
+  BFD_RELOC_RX_GOTOFFFUNCDESC,
+  BFD_RELOC_RX_FUNCDESC,
 
 /* Direct 12 bit.  */
   BFD_RELOC_390_12,

--- a/bfd/elf32-rx.c
+++ b/bfd/elf32-rx.c
@@ -39,6 +39,16 @@ char * rx_get_reloc (long);
 void rx_dump_symtab (bfd *, void *, void *);
 #endif
 
+/* Return true if OUTPUT_BFD is an FDPIC object.  */
+
+static bool
+fdpic_object_p (bfd *abfd ATTRIBUTE_UNUSED)
+{
+  extern const bfd_target rx_elf32_linux_le_vec;
+
+  return (abfd->xvec == &rx_elf32_linux_le_vec);
+}
+
 #define RXREL(n,sz,bit,shift,complain,pcrel)				     \
   HOWTO (R_RX_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
 	 bfd_elf_generic_reloc, "R_RX_" #n, false, 0, ~0, false)
@@ -76,15 +86,11 @@ static reloc_howto_type rx_elf_howto_table [] =
   RXREL (RELATIVE,     2, 32, 0, bitfield, false),
   RXREL (GOTOFF,       2, 32, 0, bitfield, false),
   RXREL (GOTPC,	       2, 32, 0, bitfield, false),
+  RXREL (GOTFUNCDESC,  2, 32, 0, signed,   false),
+  RXREL (GOTOFFFUNCDESC, 2, 32, 0, signed,  false),
+  RXREL (FUNCDESC,     2, 32, 0, signed,  false),
+  RXREL (FUNCDESC_VALUE, 2, 64, 0, signed, false),
 
-  EMPTY_HOWTO (0x17),
-  EMPTY_HOWTO (0x18),
-  EMPTY_HOWTO (0x19),
-  EMPTY_HOWTO (0x1a),
-  EMPTY_HOWTO (0x1b),
-  EMPTY_HOWTO (0x1c),
-  EMPTY_HOWTO (0x1d),
-  EMPTY_HOWTO (0x1e),
   EMPTY_HOWTO (0x1f),
 
   RXREL (RH_3_PCREL, 1,	 3, 0, signed,	 true),
@@ -239,6 +245,18 @@ static reloc_howto_type rx_elf_howto_table [] =
   RXREL (OPramtop,  4, 32, 0, dont, false)
 };
 
+/* FDPIC binaries have a default 128K stack.  */
+#define DEFAULT_STACK_SIZE 0x20000
+
+#define MINUS_ONE ((bfd_vma) 0 - 1)
+
+/* Decide whether a reference to a symbol can be resolved locally or
+   not.  If the symbol is protected, we want the local address, but
+   its function descriptor must be assigned by the dynamic linker.  */
+#define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
+  (SYMBOL_REFERENCES_LOCAL (INFO, H) \
+   || ! elf_hash_table (INFO)->dynamic_sections_created)
+
 
 /* Map BFD reloc types to RX ELF reloc types.  */
 
@@ -270,6 +288,9 @@ static const struct rx_reloc_map rx_reloc_map [] =
   { BFD_RELOC_RX_GOTPC,	 	R_RX_GOTPC },
   { BFD_RELOC_32_GOTOFF, 	R_RX_GOTOFF },
   { BFD_RELOC_32_PLT_PCREL, 	R_RX_PLT },
+  { BFD_RELOC_RX_GOTFUNCDESC,   R_RX_GOTFUNCDESC },
+  { BFD_RELOC_RX_GOTOFFFUNCDESC, R_RX_GOTOFFFUNCDESC },
+  { BFD_RELOC_RX_FUNCDESC,      R_RX_FUNCDESC },
   { BFD_RELOC_RX_24U,		R_RX_RH_24_UNS },
   { BFD_RELOC_RX_NEG8,		R_RX_RH_8_NEG },
   { BFD_RELOC_RX_NEG16,		R_RX_RH_16_NEG },
@@ -401,6 +422,38 @@ static const struct elf_rx_plt_info elf_rx_plt_info[2] =
   },
   
 };
+
+#define FDPIC_PLT_ENTRY_SIZE 28
+#define FDPIC_PLT_LAZY_OFFSET 24
+
+/* First entry in an absolute procedure linkage table look like this.  */
+static const bfd_byte fdpic_elf_rx_plt_entry[FDPIC_PLT_ENTRY_SIZE] =
+{
+  0xfb, 0xe2,		/* mov		#symoffset, r14 */
+  0, 0, 0, 0,
+  0x4b, 0xde,           /* add		r13, r14 */
+  0xed, 0xed, 0x01,   	/* mov.l	4[r14], r13 */
+  0xec, 0xee,           /* mov.l	[r14], r14 */
+  0x7f, 0x0e,		/* jmp	r14 */
+  0x03,			/* nop */
+  0xec, 0xde,           /* mov.l	[r13], r14 */
+  0xed, 0xd5, 0x01,     /* mov.l	4[r13], r5 */
+  0x7f, 0x0e,           /* jmp	r14 */
+  0x03,			/* nop */
+  0, 0, 0, 0,		/* replaced with offset into relocation table.  */
+};
+
+static const struct elf_rx_plt_info fdpic_rx_plt_info =
+  {
+    NULL,
+    0,
+    { 0, 0, 0 },
+    fdpic_elf_rx_plt_entry,
+    FDPIC_PLT_ENTRY_SIZE,
+    { 2, 0, 0 },
+    FDPIC_PLT_LAZY_OFFSET,
+  };
+
 struct elf_rx_pcrel_relocs_copied
 {
   /* Next section.  */
@@ -414,6 +467,12 @@ struct elf_rx_pcrel_relocs_copied
 /* Forward declaration.  */
 struct elf_rx_got_entry;
 
+union gotref
+{
+  bfd_signed_vma refcount;
+  bfd_vma offset;
+};
+
 /* RX ELF linker hash entry.  */
 
 struct elf_rx_link_hash_entry
@@ -422,8 +481,22 @@ struct elf_rx_link_hash_entry
 
   bfd_signed_vma gotplt_refcount;
 
+  /* A local function descriptor, for FDPIC.  The refcount counts
+     R_RX_FUNCDESC, R_RX_GOTOFFFUNCDESC, and R_RX_GOTOFFFUNCDESC20
+     relocations; the PLT and GOT entry are accounted
+     for separately.  After adjust_dynamic_symbol, the offset is
+     MINUS_ONE if there is no local descriptor (dynamic linker
+     managed and no PLT entry, or undefined weak non-dynamic).
+     During check_relocs we do not yet know whether the local
+     descriptor will be canonical.  */
+  union gotref funcdesc;
+
+  /* How many of the above refcounted relocations were R_SH_FUNCDESC,
+     and thus require fixups or relocations.  */
+  bfd_signed_vma abs_funcdesc_refcount;
+
   enum got_type {
-    GOT_UNKNOWN = 0, GOT_NORMAL, 
+    GOT_UNKNOWN = 0, GOT_NORMAL, GOT_FUNCDESC,
   } got_type;
 };
 
@@ -435,6 +508,9 @@ struct rx_elf_obj_tdata
 
   /* got_type for each local got entry.  */
   char *local_got_type;
+
+  /* Function descriptor refcount and offset for each local symbol.  */
+  union gotref *local_funcdesc;
 };
 
 #define rx_elf_tdata(abfd) \
@@ -443,7 +519,10 @@ struct rx_elf_obj_tdata
 #define rx_elf_local_got_type(abfd) \
   (rx_elf_tdata (abfd)->local_got_type)
 
-#define is_rx_elf(bfd) \
+#define rx_elf_local_funcdesc(abfd) \
+  (rx_elf_tdata (abfd)->local_funcdesc)
+
+#define is_rx_elf(bfd)				   \
   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
    && elf_tdata (bfd) != NULL \
    && elf_object_id (bfd) == RX_ELF_DATA)
@@ -462,9 +541,16 @@ rx_elf_mkobject (bfd *abfd)
     the object is position-independent.  */
  
 static const struct elf_rx_plt_info *
-get_plt_info (bfd *abfd ATTRIBUTE_UNUSED, bool pic)
+get_plt_info (bfd *abfd, bool pic)
 {
-  return &elf_rx_plt_info[pic];
+  if (fdpic_object_p (abfd))
+    {
+      return &fdpic_rx_plt_info;
+    }
+  else
+    {
+      return &elf_rx_plt_info[pic];
+    }
 }
 
 /* Do the inverse operation.  */
@@ -503,11 +589,15 @@ get_plt_index (const struct elf_rx_plt_info *info, bfd_vma offset)
 struct elf_rx_link_hash_table
 {
   struct elf_link_hash_table root;
-
+  asection *sfuncdesc;
+  asection *srelfuncdesc;
+  asection *srofixup;
 
   /* The type of PLT to use.  */
   const struct elf_rx_plt_info *plt_info;
 
+  /* True if the target system uses FDPIC.  */
+  bool fdpic_p;
 };
 
 /* Traverse an sh ELF linker hash table.  */
@@ -551,6 +641,8 @@ rx_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
   if (ret != (struct elf_rx_link_hash_entry *) NULL)
     {
       ret->gotplt_refcount = 0;
+      ret->funcdesc.refcount = 0;
+      ret->abs_funcdesc_refcount = 0;
       ret->got_type = GOT_UNKNOWN;
     }
 
@@ -578,9 +670,39 @@ rx_elf_link_hash_table_create (bfd *abfd)
       return NULL;
     }
 
+  ret->plt_info = NULL;
+  ret->fdpic_p = fdpic_object_p (abfd);
   return &ret->root.root;
 }
 
+static bool
+rx_elf_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
+			    struct bfd_link_info *info, asection *p)
+{
+  struct elf_rx_link_hash_table *htab = rx_elf_hash_table (info);
+
+  /* Non-FDPIC binaries do not need dynamic symbols for sections.  */
+  if (!htab->fdpic_p)
+    return true;
+
+  /* We need dynamic symbols for every section, since segments can
+     relocate independently.  */
+  switch (elf_section_data (p)->this_hdr.sh_type)
+    {
+    case SHT_PROGBITS:
+    case SHT_NOBITS:
+      /* If sh_type is yet undecided, assume it could be
+	 SHT_PROGBITS/SHT_NOBITS.  */
+    case SHT_NULL:
+      return false;
+
+      /* There shouldn't be section relative relocations
+	 against any other section.  */
+    default:
+      return true;
+    }
+}
+
 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
    shortcuts to them in our hash table.  */
 
@@ -596,6 +718,37 @@ create_got_section (bfd *dynobj, struct bfd_link_info *info)
   if (htab == NULL)
     return false;
 
+  htab->sfuncdesc = bfd_make_section_anyway_with_flags (dynobj, ".got.funcdesc",
+							(SEC_ALLOC | SEC_LOAD
+							 | SEC_HAS_CONTENTS
+							 | SEC_IN_MEMORY
+							 | SEC_LINKER_CREATED));
+  if (htab->sfuncdesc == NULL
+      || !bfd_set_section_alignment (htab->sfuncdesc, 2))
+    return false;
+
+  htab->srelfuncdesc = bfd_make_section_anyway_with_flags (dynobj,
+							   ".rela.got.funcdesc",
+							   (SEC_ALLOC | SEC_LOAD
+							    | SEC_HAS_CONTENTS
+							    | SEC_IN_MEMORY
+							    | SEC_LINKER_CREATED
+							    | SEC_READONLY));
+  if (htab->srelfuncdesc == NULL
+      || !bfd_set_section_alignment (htab->srelfuncdesc, 2))
+    return false;
+
+  /* Also create .rofixup.  */
+  htab->srofixup = bfd_make_section_anyway_with_flags (dynobj, ".rofixup",
+						       (SEC_ALLOC | SEC_LOAD
+							| SEC_HAS_CONTENTS
+							| SEC_IN_MEMORY
+							| SEC_LINKER_CREATED
+							| SEC_READONLY));
+  if (htab->srofixup == NULL
+      || !bfd_set_section_alignment (htab->srofixup, 2))
+    return false;
+
   return true;
 }
 
@@ -885,7 +1038,6 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
 	  || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
 	{
 	  asection *s = htab->root.splt;
-	  const struct elf_rx_plt_info *plt_info;
 
 	  /* If this is the first .plt entry, make room for the special
 	     first entry.  */
@@ -894,19 +1046,28 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
 
 	  h->plt.offset = s->size;
 
-	  if (!bfd_link_pic (info) && !h->def_regular)
+	  /* 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.  Skip this for FDPIC, since the
+	     function's address will be the address of the canonical
+	     function descriptor.  */
+	  if (!htab->fdpic_p && !bfd_link_pic (info) && !h->def_regular)
 	    {
 	      h->root.u.def.section = s;
 	      h->root.u.def.value = h->plt.offset;
 	    }
 
 	  /* Make room for this entry.  */
-	  plt_info = htab->plt_info;
-	  s->size += plt_info->symbol_entry_size;
+	  s->size += htab->plt_info->symbol_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->root.sgotplt->size += 4;
+	  if (!htab->fdpic_p)
+	    htab->root.sgotplt->size += 4;
+	  else
+	    htab->root.sgotplt->size += 8;
 
 	  /* We also need to make an entry in the .rel.plt section.  */
 	  htab->root.srelplt->size += sizeof (Elf32_External_Rela);
@@ -927,6 +1088,8 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
   if (h->got.refcount > 0)
     {
       asection *s;
+      bool dyn;
+      enum got_type got_type = rx_elf_hash_entry (h)->got_type;
 
       /* Make sure this symbol is output as a dynamic symbol.
 	 Undefined weak syms won't yet be marked as dynamic.  */
@@ -940,14 +1103,76 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
       s = htab->root.sgot;
       h->got.offset = s->size;
       s->size += 4;
-      if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+      dyn = htab->root.dynamic_sections_created;
+      if (!dyn)
+	{
+	  /* No dynamic relocations required.  */
+	  if (htab->fdpic_p && !bfd_link_pic (info)
+	      && h->root.type != bfd_link_hash_undefweak
+	      && (got_type == GOT_NORMAL || got_type == GOT_FUNCDESC))
+	    htab->srofixup->size += 4;
+	}
+      else if (got_type == GOT_FUNCDESC)
+	{
+	  if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
+	    htab->srofixup->size += 4;
+	  else
+	    htab->root.srelgot->size += sizeof (Elf32_External_Rela);
+	}
+      else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
 		|| h->root.type != bfd_link_hash_undefweak)
 	  && (bfd_link_pic (info)))
 	htab->root.srelgot->size += sizeof (Elf32_External_Rela);
+      else if (htab->fdpic_p
+	       && !bfd_link_pic (info)
+	       && got_type == GOT_NORMAL
+	       && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+		   || h->root.type != bfd_link_hash_undefweak))
+	htab->srofixup->size += 4;
     }
   else
     h->got.offset = (bfd_vma) -1;
 
+  /* Allocate space for any dynamic relocations to function
+     descriptors, canonical or otherwise.  We need to relocate the
+     reference unless it resolves to zero, which only happens for
+     undefined weak symbols (either non-default visibility, or when
+     static linking).  Any GOT slot is accounted for elsewhere.  */
+  if (eh->abs_funcdesc_refcount > 0
+      && (h->root.type != bfd_link_hash_undefweak
+	  || (htab->root.dynamic_sections_created
+	      && ! SYMBOL_CALLS_LOCAL (info, h))))
+    {
+      if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
+	htab->srofixup->size += eh->abs_funcdesc_refcount * 4;
+      else
+	htab->root.srelgot->size
+	  += eh->abs_funcdesc_refcount * sizeof (Elf32_External_Rela);
+    }
+
+  /* We must allocate a function descriptor if there are references to
+     a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
+     the dynamic linker isn't going to allocate it.  None of this
+     applies if we already created one in .got.plt, but if the
+     canonical function descriptor can be in this object, there
+     won't be a PLT entry at all.  */
+  if ((eh->funcdesc.refcount > 0
+       || (h->got.offset != MINUS_ONE && eh->got_type == GOT_FUNCDESC))
+      && h->root.type != bfd_link_hash_undefweak
+      && SYMBOL_FUNCDESC_LOCAL (info, h))
+    {
+      /* Make room for this function descriptor.  */
+      eh->funcdesc.offset = htab->sfuncdesc->size;
+      htab->sfuncdesc->size += 8;
+
+      /* We will need a relocation or two fixups to initialize the
+	 function descriptor, so allocate those too.  */
+      if (!bfd_link_pic(info) && SYMBOL_CALLS_LOCAL (info, h))
+	htab->srofixup->size += 8;
+      else
+	htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
+    }
+
   if (h->dyn_relocs == NULL)
     return true;
 
@@ -1044,11 +1269,32 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
     {
       asection *sreloc = elf_section_data (p->sec)->sreloc;
       sreloc->size += p->count * sizeof (Elf32_External_Rela);
+
+      /* If we need relocations, we do not need fixups.  */
+      if (htab->fdpic_p && !bfd_link_pic(info))
+	htab->srofixup->size -= 4 * (p->count - p->pc_count);
     }
 
   return true;
 }
 
+/* This function is called after all the input files have been read,
+   and the input sections have been assigned to output sections.
+   It's a convenient place to determine the PLT style.  */
+
+static bool
+rx_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
+{
+  rx_elf_hash_table (info)->plt_info = get_plt_info (output_bfd,
+						     bfd_link_pic (info));
+
+  if (rx_elf_hash_table (info)->fdpic_p && !bfd_link_relocatable (info)
+      && !bfd_elf_stack_segment_size (output_bfd, info,
+				      "__stacksize", DEFAULT_STACK_SIZE))
+    return false;
+  return true;
+}
+
 static bool
 rx_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 			      struct bfd_link_info *info)
@@ -1072,10 +1318,11 @@ rx_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
     {
       bfd_signed_vma *local_got;
       bfd_signed_vma *end_local_got;
-      char *local_got_type;
       bfd_size_type locsymcount;
       Elf_Internal_Shdr *symtab_hdr;
       asection *srel;
+      union gotref *local_funcdesc, *end_local_funcdesc;
+      char *local_got_type;
 
       if (! is_rx_elf (ibfd))
 	continue;
@@ -1113,6 +1360,10 @@ rx_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 		      info->flags |= DF_TEXTREL;
 		      info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
 					      p->sec->owner, p->sec);
+
+		      /* If we need relocations, we do not need fixups.  */
+		      if (htab->fdpic_p && !bfd_link_pic(info))
+			htab->srofixup->size -= 4 * (p->count - p->pc_count);
 		    }
 		}
 	    }
@@ -1128,26 +1379,88 @@ rx_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	{
 	  end_local_got = local_got + locsymcount;
 	  local_got_type = rx_elf_local_got_type (ibfd);
+	  local_funcdesc = rx_elf_local_funcdesc (ibfd);
 	  for (; local_got < end_local_got; ++local_got)
 	    {
 	      if (*local_got > 0)
 		{
 		  *local_got = s->size;
 		  s->size += 4;
-		  if (bfd_link_pic (info))
+		  if (bfd_link_pic(info))
 		    srel->size += sizeof (Elf32_External_Rela);
+		  else
+		    htab->srofixup->size += 4;
+
+		  if (*local_got_type == GOT_FUNCDESC)
+		    {
+		      if (local_funcdesc == NULL)
+			{
+			  bfd_size_type size;
+
+			  size = locsymcount * sizeof (union gotref);
+			  local_funcdesc = (union gotref *) bfd_zalloc (ibfd,
+									size);
+			  if (local_funcdesc == NULL)
+			    return false;
+			  rx_elf_local_funcdesc (ibfd) = local_funcdesc;
+			  local_funcdesc += (local_got
+					     - elf_local_got_refcounts (ibfd));
+			}
+		      local_funcdesc->refcount++;
+		      ++local_funcdesc;
+		    }
 		}
 	      else
 		*local_got = (bfd_vma) -1;
 	      ++local_got_type;
 	    }
 	}
+      local_funcdesc = rx_elf_local_funcdesc (ibfd);
+      if (local_funcdesc)
+	{
+	  end_local_funcdesc = local_funcdesc + locsymcount;
+
+	  for (; local_funcdesc < end_local_funcdesc; ++local_funcdesc)
+	    {
+	      if (local_funcdesc->refcount > 0)
+		{
+		  local_funcdesc->offset = htab->sfuncdesc->size;
+		  htab->sfuncdesc->size += 8;
+		  if (!bfd_link_pic (info))
+		    htab->srofixup->size += 8;
+		  else
+		    htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
+		}
+	      else
+		local_funcdesc->offset = MINUS_ONE;
+	    }
+	}
+    }
+
+  /* Only the reserved entries should be present.  For FDPIC, they go at
+     the end of .got.plt.  */
+  if (htab->fdpic_p)
+    {
+      BFD_ASSERT (htab->root.sgotplt && htab->root.sgotplt->size == 12);
+      htab->root.sgotplt->size = 0;
     }
 
   /* Allocate global sym .plt and .got entries, and space for global
      sym dynamic relocs.  */
   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
 
+  /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
+     end of the FDPIC .got.plt.  */
+  if (htab->fdpic_p)
+    {
+      htab->root.hgot->root.u.def.value = htab->root.sgotplt->size;
+      htab->root.sgotplt->size += 12;
+    }
+
+  /* At the very end of the .rofixup section is a pointer to the GOT.  */
+  if (htab->fdpic_p && htab->srofixup != NULL)
+    htab->srofixup->size += 4;
+
   /* We now have determined the sizes of the various dynamic sections.
      Allocate memory for them.  */
   relocs = false;
@@ -1159,6 +1472,8 @@ rx_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
       if (s == htab->root.splt
 	  || s == htab->root.sgot
 	  || s == htab->root.sgotplt
+	  || s == htab->sfuncdesc
+	  || s == htab->srofixup
 	  || s == htab->root.sdynbss)
 	{
 	  /* Strip this section if we don't need it; see the
@@ -1206,6 +1521,153 @@ rx_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
   return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
 }
 
+/* Add a dynamic relocation to the SRELOC section.  */
+
+inline static bfd_vma
+rx_elf_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
+		      int reloc_type, long dynindx, bfd_vma addend)
+{
+  Elf_Internal_Rela outrel;
+  bfd_vma reloc_offset;
+
+  outrel.r_offset = offset;
+  outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
+  outrel.r_addend = addend;
+
+  reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rela);
+  BFD_ASSERT (reloc_offset < sreloc->size);
+  bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+			     sreloc->contents + reloc_offset);
+  sreloc->reloc_count++;
+
+  return reloc_offset;
+}
+
+/* Add an FDPIC read-only fixup.  */
+
+inline static void
+rx_elf_add_rofixup (bfd *output_bfd, asection *srofixup, bfd_vma offset)
+{
+  bfd_vma fixup_offset;
+
+  fixup_offset = srofixup->reloc_count++ * 4;
+  BFD_ASSERT (fixup_offset < srofixup->size);
+  bfd_put_32 (output_bfd, offset, srofixup->contents + fixup_offset);
+}
+
+#if 0
+/* Return the offset of the generated .got section from the
+   _GLOBAL_OFFSET_TABLE_ symbol.  */
+
+static bfd_signed_vma
+rx_elf_got_offset (struct elf_rx_link_hash_table *htab)
+{
+  return (htab->root.sgot->output_offset - htab->root.sgotplt->output_offset
+	  - htab->root.hgot->root.u.def.value);
+}
+#endif
+
+/* Find the segment number in which OSEC, and output section, is
+   located.  */
+
+static unsigned
+rx_elf_osec_to_segment (bfd *output_bfd, asection *osec)
+{
+  Elf_Internal_Phdr *p = NULL;
+
+  if (output_bfd->xvec->flavour == bfd_target_elf_flavour
+      /* PR ld/17110: Do not look for output segments in an input bfd.  */
+      && output_bfd->direction != read_direction)
+    p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
+
+  /* FIXME: Nothing ever says what this index is relative to.  The kernel
+     supplies data in terms of the number of load segments but this is
+     a phdr index and the first phdr may not be a load segment.  */
+  return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
+}
+
+static bool
+rx_elf_osec_readonly_p (bfd *output_bfd, asection *osec)
+{
+  unsigned seg = rx_elf_osec_to_segment (output_bfd, osec);
+
+  return (seg != (unsigned) -1
+	  && ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W));
+}
+
+/* Generate the initial contents of a local function descriptor, along
+   with any relocations or fixups required.  */
+static bool
+rx_elf_initialize_funcdesc (bfd *output_bfd,
+			    struct bfd_link_info *info,
+			    struct elf_link_hash_entry *h,
+			    bfd_vma offset,
+			    asection *section,
+			    bfd_vma value)
+{
+  struct elf_rx_link_hash_table *htab;
+  int dynindx;
+  bfd_vma addr, seg;
+
+  htab = rx_elf_hash_table (info);
+
+  /* FIXME: The ABI says that the offset to the function goes in the
+     descriptor, along with the segment index.  We're RELA, so it could
+     go in the reloc instead... */
+
+  if (h != NULL && SYMBOL_CALLS_LOCAL (info, h))
+    {
+      section = h->root.u.def.section;
+      value = h->root.u.def.value;
+    }
+
+  if (h == NULL || SYMBOL_CALLS_LOCAL (info, h))
+    {
+      dynindx = elf_section_data (section->output_section)->dynindx;
+      addr = value + section->output_offset;
+      seg = rx_elf_osec_to_segment (output_bfd, section->output_section);
+    }
+  else
+    {
+      BFD_ASSERT (h->dynindx != -1);
+      dynindx = h->dynindx;
+      addr = seg = 0;
+    }
+
+  if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h))
+    {
+      if (h == NULL || h->root.type != bfd_link_hash_undefweak)
+	{
+	  rx_elf_add_rofixup (output_bfd, htab->srofixup,
+			      offset
+			      + htab->sfuncdesc->output_section->vma
+			      + htab->sfuncdesc->output_offset);
+	  rx_elf_add_rofixup (output_bfd, htab->srofixup,
+			      offset + 4
+			      + htab->sfuncdesc->output_section->vma
+			      + htab->sfuncdesc->output_offset);
+	}
+
+      /* There are no dynamic relocations so fill in the final
+	 address and gp value (barring fixups).  */
+      addr += section->output_section->vma;
+      seg = htab->root.hgot->root.u.def.value
+	+ htab->root.hgot->root.u.def.section->output_section->vma
+	+ htab->root.hgot->root.u.def.section->output_offset;
+    }
+  else
+    rx_elf_add_dyn_reloc (output_bfd, htab->srelfuncdesc,
+			  offset
+			  + htab->sfuncdesc->output_section->vma
+			  + htab->sfuncdesc->output_offset,
+			  R_RX_FUNCDESC_VALUE, dynindx, 0);
+
+  bfd_put_32 (output_bfd, addr, htab->sfuncdesc->contents + offset);
+  bfd_put_32 (output_bfd, seg, htab->sfuncdesc->contents + offset + 4);
+
+  return true;
+}
+
 /* Finish up dynamic symbol handling.  We set the contents of various
    dynamic sections here.  */
 
@@ -1252,9 +1714,15 @@ rx_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
 
       /* Get the offset into the .got table of the entry that
 	 corresponds to this function.  */
-      /* Each .got entry is 4 bytes.  The first three are
-	 reserved.  */
-      got_offset = (plt_index + 3) * 4;
+      if (htab->fdpic_p)
+	/* The offset must be relative to the GOT symbol, twelve bytes
+	   before the end of .got.plt.  Each descriptor is eight
+	   bytes.  */
+	got_offset = plt_index * 8 + 12 - sgotplt->size;
+      else
+	/* Each .got entry is 4 bytes.  The first three are
+	   reserved.  */
+	got_offset = (plt_index + 3) * 4;
 
 #ifdef GOT_BIAS
       if (bfd_link_pic (info))
@@ -1266,7 +1734,7 @@ rx_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
 	      plt_info->symbol_entry,
 	      plt_info->symbol_entry_size);
 
-      if (bfd_link_pic (info))
+      if (bfd_link_pic (info) || htab->fdpic_p)
 	{
 	    install_plt_field (output_bfd, false, got_offset,
 			       (splt->contents
@@ -1294,6 +1762,16 @@ rx_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
       if (bfd_link_pic (info))
 	got_offset += GOT_BIAS;
 #endif
+      if (htab->fdpic_p)
+	got_offset = plt_index * 8;
+
+      if (plt_info->symbol_fields.reloc_offset != 0)
+	install_plt_field (output_bfd, false,
+			   plt_index * sizeof (Elf32_External_Rela),
+			   (splt->contents
+			    + h->plt.offset
+			    + plt_info->symbol_fields.reloc_offset));
+
       /* Fill in the entry in the global offset table.  */
       bfd_put_32 (output_bfd,
 		  (splt->output_section->vma
@@ -1301,6 +1779,11 @@ rx_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
 		   + h->plt.offset
 		   + plt_info->symbol_resolve_offset),
 		  sgotplt->contents + got_offset);
+      if (htab->fdpic_p)
+	bfd_put_32 (output_bfd,
+		    rx_elf_osec_to_segment (output_bfd, splt->output_section),
+		    sgotplt->contents + got_offset + 4);
+
       /* Fill in the entry in the .rela.plt section.  */
       rel.r_offset = (sgotplt->output_section->vma
 		      + sgotplt->output_offset
@@ -1321,7 +1804,8 @@ rx_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
 	}
     }
 
-  if (h->got.offset != (bfd_vma) -1)
+  if (h->got.offset != (bfd_vma) -1
+      && rx_elf_hash_entry (h)->got_type != GOT_FUNCDESC)
     {
       asection *sgot;
       asection *srelgot;
@@ -1462,7 +1946,7 @@ rx_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
 
 	  memcpy (splt->contents,
 		  htab->plt_info->plt0_entry,
-		  htab->plt_info->plt0_entry_size);
+                 htab->plt_info->plt0_entry_size);
 	  for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++)
 	    if (htab->plt_info->plt0_got_fields[i] != 0)
 	      install_plt_field (output_bfd, false,
@@ -1494,6 +1978,28 @@ rx_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
   if (sgotplt && sgotplt->size > 0)
     elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
 
+  /* At the very end of the .rofixup section is a pointer to the GOT.  */
+  if (htab->fdpic_p && htab->srofixup != NULL)
+    {
+      struct elf_link_hash_entry *hgot = htab->root.hgot;
+      bfd_vma got_value = hgot->root.u.def.value
+	+ hgot->root.u.def.section->output_section->vma
+	+ hgot->root.u.def.section->output_offset;
+
+      rx_elf_add_rofixup (output_bfd, htab->srofixup, got_value);
+
+      /* Make sure we allocated and generated the same number of fixups.  */
+      BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size);
+    }
+
+  if (htab->srelfuncdesc)
+    BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela)
+		== htab->srelfuncdesc->size);
+
+  if (htab->root.srelgot)
+    BFD_ASSERT (htab->root.srelgot->reloc_count * sizeof (Elf32_External_Rela)
+		== htab->root.srelgot->size);
+
   return true;
 }
 
@@ -1576,8 +2082,16 @@ rx_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
 	  switch (r_type)
 	    {
 	    case R_RX_DIR32:
+	      /* This may require an rofixup.  */
+	      if (!htab->fdpic_p)
+		break;
+	      /* Fall through.  */
 	    case R_RX_GOT:
 	    case R_RX_GOTOFF:
+	    case R_RX_FUNCDESC:
+	    case R_RX_GOTFUNCDESC:
+	    case R_RX_GOTOFFFUNCDESC:
+	    case R_RX_GOTPC:
 	      if (htab->root.dynobj == NULL)
 		htab->root.dynobj = abfd;
 	      if (!create_got_section (htab->root.dynobj, info))
@@ -1753,7 +2267,9 @@ rx_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
 
 	      p->count += 1;
 	    }
-
+	  if (htab->fdpic_p && !bfd_link_pic (info)
+	      && (sec->flags & SEC_ALLOC) != 0)
+	    htab->srofixup->size += 4;
 	  break;
 
 	default:
@@ -2005,8 +2521,10 @@ rx_elf_relocate_section
   asection *sgotplt = NULL;
   asection *splt = NULL;
   asection *srelgot = NULL;
-  unsigned got_segment, plt_segment, check_segment[2];
+  asection *sreloc = NULL;
+  unsigned isec_segment, got_segment, plt_segment, check_segment[2];
   bfd_vma *local_got_offsets;
+  bool fdpic_p = false;
 
   if (elf_elfheader (output_bfd)->e_flags & E_FLAG_RX_PID)
     pid_mode = true;
@@ -2020,13 +2538,25 @@ rx_elf_relocate_section
       sgotplt = htab->root.sgotplt;
       srelgot = htab->root.srelgot;
       splt = htab->root.splt;
+      fdpic_p = htab->fdpic_p;
     }
   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
   sym_hashes = elf_sym_hashes (input_bfd);
   relend     = relocs + input_section->reloc_count;
   local_got_offsets = elf_local_got_offsets (input_bfd);
-  got_segment = -1;
-  plt_segment = -1;
+
+  isec_segment = rx_elf_osec_to_segment (output_bfd,
+					 input_section->output_section);
+  if (fdpic_p && sgot)
+    got_segment = rx_elf_osec_to_segment (output_bfd,
+					  sgot->output_section);
+  else
+    got_segment = -1;
+  if (fdpic_p && splt)
+    plt_segment = rx_elf_osec_to_segment (output_bfd,
+					  splt->output_section);
+  else
+    plt_segment = -1;
 
   for (rel = relocs; rel < relend; rel ++)
     {
@@ -2311,6 +2841,9 @@ rx_elf_relocate_section
 		  || (r_type == R_RX_PLT
 		      && h->plt.offset != (bfd_vma) -1)
 		  || ((r_type == R_RX_GOT
+		       || r_type == R_RX_GOTFUNCDESC
+		       || r_type == R_RX_GOTOFFFUNCDESC
+		       || r_type == R_RX_FUNCDESC)
 		      && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
 							  bfd_link_pic (info),
 							  h)
@@ -2339,7 +2872,7 @@ rx_elf_relocate_section
 		     thus ld.so will not process them.  */
 		  || (sec->output_section == NULL
 		      && ((input_section->flags & SEC_DEBUGGING) != 0
-			  && h->def_dynamic))))
+			  && h->def_dynamic)))
 		;
 	      else if (sec->output_section != NULL)
 		relocation = (h->root.u.def.value
@@ -2384,6 +2917,16 @@ rx_elf_relocate_section
       if (bfd_link_relocatable (info))
 	continue;
 
+      /* Check for inter-segment relocations in FDPIC files.  Most
+	 relocations connect the relocation site to the location of
+	 the target symbol, but there are some exceptions below.  */
+      check_segment[0] = isec_segment;
+      if (sec != NULL)
+	check_segment[1] = rx_elf_osec_to_segment (output_bfd,
+						   sec->output_section);
+      else
+	check_segment[1] = -1;
+      
 #define RANGE(a,b) \
   if (a > (long) relocation || (long) relocation > b)		\
     r = bfd_reloc_overflow
@@ -2646,6 +3189,108 @@ rx_elf_relocate_section
 	  break;
 
 	case R_RX_DIR32:
+	  if (bfd_link_pic (info)
+	      && (h == NULL
+		  || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+		      && !resolved_to_zero)
+		  || h->root.type != bfd_link_hash_undefweak)
+	      && r_symndx != STN_UNDEF
+	      && (input_section->flags & SEC_ALLOC) != 0
+	      && !SYMBOL_CALLS_LOCAL (info, h))
+	    {
+	      Elf_Internal_Rela outrel;
+	      bfd_byte *loc;
+	      bool skip, relocate;
+
+	      /* When generating a shared object, these relocations
+		 are copied into the output file to be resolved at run
+		 time.  */
+
+	      if (sreloc == NULL)
+		{
+		  sreloc = _bfd_elf_get_dynamic_reloc_section
+		    (input_bfd, input_section, /*rela?*/ true);
+		  if (sreloc == NULL)
+		    return false;
+		}
+
+	      skip = false;
+	      relocate = false;
+
+	      outrel.r_offset =
+		_bfd_elf_section_offset (output_bfd, info, input_section,
+					 rel->r_offset);
+	      if (outrel.r_offset == (bfd_vma) -1)
+		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);
+
+	      if (skip)
+		memset (&outrel, 0, sizeof outrel);
+	      else if (fdpic_p
+		       && (h == NULL
+			   || ((info->symbolic || h->dynindx == -1)
+			       && h->def_regular)))
+		{
+		  int dynindx;
+
+		  BFD_ASSERT (sec != NULL);
+		  BFD_ASSERT (sec->output_section != NULL);
+		  dynindx = elf_section_data (sec->output_section)->dynindx;
+		  outrel.r_info = ELF32_R_INFO (dynindx, R_RX_DIR32);
+		  outrel.r_addend = relocation;
+		  outrel.r_addend
+		    += (howto->partial_inplace
+			? bfd_get_32 (input_bfd, contents + rel->r_offset)
+			: addend);
+		  outrel.r_addend -= sec->output_section->vma;
+		}
+	      loc = sreloc->contents;
+	      loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
+	      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
+
+	      check_segment[0] = check_segment[1] = -1;
+
+	      /* 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;
+	    }
+	  else if (fdpic_p && !bfd_link_pic (info)
+		   && (input_section->flags & SEC_ALLOC) != 0)
+	    {
+	      bfd_vma offset;
+
+	      BFD_ASSERT (htab);
+
+		if (rx_elf_osec_readonly_p (output_bfd,
+					    input_section->output_section))
+		  {
+		    _bfd_error_handler
+		      /* xgettext:c-format */
+		      (_("%pB(%pA+%#" PRIx64 "): "
+			 "cannot emit fixup to `%s' in read-only section"),
+		       input_bfd,
+		       input_section,
+		       (uint64_t) rel->r_offset,
+		       symname);
+		    return false;
+		  }
+
+	      offset = _bfd_elf_section_offset (output_bfd, info,
+						input_section, rel->r_offset);
+	      if (offset != (bfd_vma)-1)
+		rx_elf_add_rofixup (output_bfd, htab->srofixup,
+				    input_section->output_section->vma
+				    + input_section->output_offset
+				    + rel->r_offset);
+
+	      check_segment[0] = check_segment[1] = -1;
+	    }
 	  if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
 	    {
 	      OP (3) = relocation;
@@ -3240,6 +3885,10 @@ rx_elf_relocate_section
 #ifdef GOT_BIAS
 	  relocation -= GOT_BIAS;
 #endif
+	  OP (0) = relocation;
+	  OP (1) = relocation >> 8;
+	  OP (2) = relocation >> 16;
+	  OP (3) = relocation >> 24;
 
 	  break;
 
@@ -3272,6 +3921,10 @@ rx_elf_relocate_section
 #endif
 
 	  addend = rel->r_addend;
+	  OP (0) = relocation;
+	  OP (1) = relocation >> 8;
+	  OP (2) = relocation >> 16;
+	  OP (3) = relocation >> 24;
 
 	  break;
 
@@ -3315,11 +3968,306 @@ rx_elf_relocate_section
 	  OP (2) = relocation >> 16;
 
 	  break;
+	/* Relocation is to the canonical function descriptor for this
+	   symbol, possibly via the GOT.  Initialize the GOT
+	   entry and function descriptor if necessary.  */
+	case R_RX_GOTFUNCDESC:
+	case R_RX_FUNCDESC:
+	  {
+	    int dynindx = -1;
+	    asection *reloc_section;
+	    bfd_vma reloc_offset;
+	    int reloc_type = R_RX_FUNCDESC;
+
+	    check_segment[0] = check_segment[1] = -1;
+
+	    /* FIXME: See what FRV does for global symbols in the
+	       executable, with --export-dynamic.  Do they need ld.so
+	       to allocate official descriptors?  See what this code
+	       does.  */
+
+	    relocation = 0;
+	    addend = 0;
+
+	    if (r_type == R_RX_FUNCDESC)
+	      {
+		reloc_section = input_section;
+		reloc_offset = rel->r_offset;
+	      }
+	    else
+	      {
+		reloc_section = htab->root.sgot;
+
+		if (h != NULL)
+		  reloc_offset = h->got.offset;
+		else
+		  {
+		    BFD_ASSERT (local_got_offsets != NULL);
+		    reloc_offset = local_got_offsets[r_symndx];
+		  }
+		BFD_ASSERT (reloc_offset != MINUS_ONE);
+
+		if (reloc_offset & 1)
+		  {
+		    reloc_offset &= ~1;
+		    goto funcdesc_done_got;
+		  }
+	      }
+
+	    if (h && h->root.type == bfd_link_hash_undefweak
+		&& (SYMBOL_CALLS_LOCAL (info, h)
+		    || !htab->root.dynamic_sections_created))
+	      /* Undefined weak symbol which will not be dynamically
+		 resolved later; leave it at zero.  */
+	      goto funcdesc_leave_zero;
+	    else if (SYMBOL_CALLS_LOCAL (info, h)
+		     && ! SYMBOL_FUNCDESC_LOCAL (info, h))
+	      {
+		/* If the symbol needs a non-local function descriptor
+		   but binds locally (i.e., its visibility is
+		   protected), emit a dynamic relocation decayed to
+		   section+offset.  This is an optimization; the dynamic
+		   linker would resolve our function descriptor request
+		   to our copy of the function anyway.  */
+		dynindx = elf_section_data (h->root.u.def.section
+					    ->output_section)->dynindx;
+		relocation += h->root.u.def.section->output_offset
+		  + h->root.u.def.value;
+	      }
+	    else if (! SYMBOL_FUNCDESC_LOCAL (info, h))
+	      {
+		/* If the symbol is dynamic and there will be dynamic
+		   symbol resolution because we are or are linked with a
+		   shared library, emit a FUNCDESC relocation such that
+		   the dynamic linker will allocate the function
+		   descriptor.  */
+		BFD_ASSERT (h->dynindx != -1);
+		dynindx = h->dynindx;
+	      }
+	    else
+	      {
+		bfd_vma offset;
+
+		/* Otherwise, we know we have a private function
+		   descriptor, so reference it directly.  */
+		reloc_type = R_RX_DIR32;
+		dynindx = elf_section_data (htab->sfuncdesc
+					    ->output_section)->dynindx;
+
+		if (h)
+		  {
+		    offset = rx_elf_hash_entry (h)->funcdesc.offset;
+		    BFD_ASSERT (offset != MINUS_ONE);
+		    if ((offset & 1) == 0)
+		      {
+			if (!rx_elf_initialize_funcdesc (output_bfd, info, h,
+							 offset, NULL, 0))
+			  return false;
+			rx_elf_hash_entry (h)->funcdesc.offset |= 1;
+		      }
+		  }
+		else
+		  {
+		    union gotref *local_funcdesc;
+
+		    local_funcdesc = rx_elf_local_funcdesc (input_bfd);
+		    offset = local_funcdesc[r_symndx].offset;
+		    BFD_ASSERT (offset != MINUS_ONE);
+		    if ((offset & 1) == 0)
+		      {
+			if (!rx_elf_initialize_funcdesc (output_bfd, info, NULL,
+							 offset, sec,
+							 sym->st_value))
+			  return false;
+			local_funcdesc[r_symndx].offset |= 1;
+		      }
+		  }
+
+		relocation = htab->sfuncdesc->output_offset + (offset & ~1);
+	      }
+
+	    if (!bfd_link_pic(info) && SYMBOL_FUNCDESC_LOCAL (info, h))
+	      {
+		bfd_vma offset;
+
+		BFD_ASSERT (htab);
+
+		if (rx_elf_osec_readonly_p (output_bfd,
+					    input_section->output_section))
+		  {
+		    _bfd_error_handler
+		      /* xgettext:c-format */
+		      (_("%pB(%pA+%#" PRIx64 "): "
+			 "cannot emit fixup to `%s' in read-only section"),
+		       input_bfd,
+		       input_section,
+		       (uint64_t) rel->r_offset,
+		       symname);
+		    return false;
+		  }
+
+		offset = _bfd_elf_section_offset (output_bfd, info,
+						  reloc_section, reloc_offset);
+
+		if (offset != (bfd_vma)-1)
+		  rx_elf_add_rofixup (output_bfd, htab->srofixup,
+				      offset
+				      + reloc_section->output_section->vma
+				      + reloc_section->output_offset);
+	      }
+	    else if ((reloc_section->output_section->flags
+		      & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
+	      {
+		bfd_vma offset;
+
+		if (rx_elf_osec_readonly_p (output_bfd,
+					    reloc_section->output_section))
+		  {
+		    info->callbacks->warning
+		      (info,
+		       _("cannot emit dynamic relocations in read-only section"),
+		       symname, input_bfd, reloc_section, reloc_offset);
+		    return false;
+		  }
+
+		offset = _bfd_elf_section_offset (output_bfd, info,
+						  reloc_section, reloc_offset);
+
+		if (offset != (bfd_vma)-1)
+		  rx_elf_add_dyn_reloc (output_bfd, srelgot,
+					offset
+					+ reloc_section->output_section->vma
+					+ reloc_section->output_offset,
+					reloc_type, dynindx, relocation);
+
+		if (r_type == R_RX_FUNCDESC)
+		  {
+		    r = bfd_reloc_ok;
+		    break;
+		  }
+		else
+		  {
+		    relocation = 0;
+		    goto funcdesc_leave_zero;
+		  }
+	      }
+	    if (SYMBOL_FUNCDESC_LOCAL (info, h))
+	      relocation += htab->sfuncdesc->output_section->vma;
+	  funcdesc_leave_zero:
+	    if (r_type != R_RX_FUNCDESC)
+	      {
+		bfd_put_32 (output_bfd, relocation,
+			    reloc_section->contents + reloc_offset);
+		if (h != NULL)
+		  h->got.offset |= 1;
+		else
+		  local_got_offsets[r_symndx] |= 1;
 
+	      funcdesc_done_got:
+
+		relocation = rx_elf_got_offset (htab) + reloc_offset;
+#ifdef GOT_BIAS
+		relocation -= GOT_BIAS;
+#endif
+	      }
+	    OP (0) = relocation;
+	    OP (1) = relocation >> 8;
+	    OP (2) = relocation >> 16;
+	    OP (3) = relocation >> 24;
+	  }
+	  break;
+
+	case R_RX_GOTOFFFUNCDESC:
+
+	  check_segment[0] = check_segment[1] = -1;
+	  relocation = 0;
+	  addend = rel->r_addend;
+
+	  if (h && (h->root.type == bfd_link_hash_undefweak
+		    || !SYMBOL_FUNCDESC_LOCAL (info, h)))
+	    {
+	      _bfd_error_handler
+		/* xgettext:c-format */
+		(_("%pB(%pA+%#" PRIx64 "): "
+		   "%s relocation against external symbol \"%s\""),
+		 input_bfd, input_section, (uint64_t) rel->r_offset,
+		 howto->name, h->root.root.string);
+	      return false;
+	    }
+	  else
+	    {
+	      bfd_vma offset;
+
+	      /* Otherwise, we know we have a private function
+		 descriptor, so reference it directly.  */
+	      if (h)
+		{
+		  offset = rx_elf_hash_entry (h)->funcdesc.offset;
+		  BFD_ASSERT (offset != MINUS_ONE);
+		  if ((offset & 1) == 0)
+		    {
+		      if (!rx_elf_initialize_funcdesc (output_bfd, info, h,
+						       offset, NULL, 0))
+			return false;
+		      rx_elf_hash_entry (h)->funcdesc.offset |= 1;
+		    }
+		}
+	      else
+		{
+		  union gotref *local_funcdesc;
+
+		  local_funcdesc = rx_elf_local_funcdesc (input_bfd);
+		  offset = local_funcdesc[r_symndx].offset;
+		  BFD_ASSERT (offset != MINUS_ONE);
+		  if ((offset & 1) == 0)
+		    {
+		      if (!rx_elf_initialize_funcdesc (output_bfd, info, NULL,
+						       offset, sec,
+						       sym->st_value))
+			return false;
+		      local_funcdesc[r_symndx].offset |= 1;
+		    }
+		}
+
+	      relocation = htab->sfuncdesc->output_offset + (offset & ~1);
+	    }
+
+	  relocation -= htab->root.hgot->root.u.def.value
+	    + htab->root.sgotplt->output_offset;
+#ifdef GOT_BIAS
+	  relocation -= GOT_BIAS;
+#endif
+	  OP (0) = relocation;
+	  OP (1) = relocation >> 8;
+	  OP (2) = relocation >> 16;
+	  OP (3) = relocation >> 24;
+	  break;
+	  
 	default:
 	  r = bfd_reloc_notsupported;
 	  break;
 	}
+      if (htab->fdpic_p && check_segment[0] != (unsigned) -1
+	  && check_segment[0] != check_segment[1])
+	{
+	  /* We don't want duplicate errors for undefined symbols.  */
+	  if (!h || h->root.type != bfd_link_hash_undefined)
+	    {
+	      if (bfd_link_pic(info))
+		{
+		  info->callbacks->einfo
+		    (_("%X%C: relocation to \"%s\" references a different segment\n"),
+		     input_bfd, input_section, rel->r_offset, symname);
+		  return false;
+		}
+	      else
+		info->callbacks->einfo
+		  (_("%C: warning: relocation to \"%s\" references a different segment\n"),
+		   input_bfd, input_section, rel->r_offset, symname);
+	    }
+
+	  elf_elfheader (output_bfd)->e_flags &= ~EF_RX_PIC;
+	}
 
       if (r != bfd_reloc_ok)
 	{
@@ -5974,6 +6922,8 @@ rx_additional_link_map_text (bfd *obfd, struct bfd_link_info *info, FILE *mapfil
 #undef  bfd_elf32_mkobject
 #define bfd_elf32_mkobject		rx_elf_mkobject
 
+#undef  elf_backend_omit_section_dynsym
+#define elf_backend_omit_section_dynsym	rx_elf_omit_section_dynsym
 #undef  elf_backend_create_dynamic_sections
 #define elf_backend_create_dynamic_sections \
 					rx_elf_create_dynamic_sections
@@ -5983,6 +6933,9 @@ rx_additional_link_map_text (bfd *obfd, struct bfd_link_info *info, FILE *mapfil
 #undef  elf_backend_adjust_dynamic_symbol
 #define elf_backend_adjust_dynamic_symbol \
 					rx_elf_adjust_dynamic_symbol
+#undef elf_backend_always_size_sections
+#define elf_backend_always_size_sections \
+					rx_elf_always_size_sections
 #undef  elf_backend_size_dynamic_sections
 #define elf_backend_size_dynamic_sections \
 					rx_elf_size_dynamic_sections
@@ -5996,6 +6949,9 @@ rx_additional_link_map_text (bfd *obfd, struct bfd_link_info *info, FILE *mapfil
 #define elf_backend_plt_sym_val		rx_elf_plt_sym_val
 #undef  elf_backend_check_relocs
 #define elf_backend_check_relocs	rx_elf_check_relocs
+#undef elf_backend_modify_program_headers
+#define elf_backend_modify_program_headers \
+					rx_elf_modify_program_headers
 
 #undef  elf_backend_want_got_plt
 #define elf_backend_want_got_plt	1

--- a/bfd/libbfd.h
+++ b/bfd/libbfd.h
@@ -2484,6 +2484,9 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@",
   "BFD_RELOC_RX_GOTOFF",
   "BFD_RELOC_RX_PLT",
   "BFD_RELOC_RX_GOTPC",
+  "BFD_RELOC_RX_GOTFUNCDESC",
+  "BFD_RELOC_RX_GOTOFFFUNCDESC",
+  "BFD_RELOC_RX_FUNCDESC",
   "BFD_RELOC_390_12",
   "BFD_RELOC_390_GOT12",
   "BFD_RELOC_390_PLT32",

--- a/bfd/reloc.c
+++ b/bfd/reloc.c
@@ -5369,6 +5369,12 @@ ENUMX
   BFD_RELOC_RX_PLT
 ENUMX
   BFD_RELOC_RX_GOTPC
+ENUMX
+  BFD_RELOC_RX_GOTFUNCDESC
+ENUMX
+  BFD_RELOC_RX_GOTOFFFUNCDESC
+ENUMX
+  BFD_RELOC_RX_FUNCDESC
 ENUMDOC
   Renesas RX Relocations.
 

--- a/gas/config/tc-rx.c
+++ b/gas/config/tc-rx.c
@@ -40,6 +40,9 @@ const char line_separator_chars[] = "!";
 
 const char EXP_CHARS[]            = "eE";
 const char FLT_CHARS[]            = "dD";
+
+/* Whether --fdpic was given.  */
+static bool fdpic = false;
 
 #ifndef TE_LINUX
 bool rx_use_conventional_section_names = false;
@@ -76,6 +79,7 @@ enum options
   OPTION_USES_RX_ABI,
   OPTION_CPU,
   OPTION_DISALLOW_STRING_INSNS,
+  OPTION_FDPIC,
 };
 
 #define RX_SHORTOPTS ""
@@ -104,6 +108,7 @@ struct option md_longopts[] =
   {"mrx-abi", no_argument, NULL, OPTION_USES_RX_ABI},
   {"mcpu", required_argument, NULL, OPTION_CPU},
   {"mno-allow-string-insns", no_argument, NULL, OPTION_DISALLOW_STRING_INSNS},
+  {"fdpic", no_argument, NULL, OPTION_FDPIC},
   {NULL, no_argument, NULL, 0}
 };
 size_t md_longopts_size = sizeof (md_longopts);
@@ -199,6 +204,9 @@ md_parse_option (int c ATTRIBUTE_UNUSED, const char * arg ATTRIBUTE_UNUSED)
     case OPTION_DISALLOW_STRING_INSNS:
       elf_flags |= E_FLAG_RX_SINSNS_SET | E_FLAG_RX_SINSNS_NO;
       return 1;
+    case OPTION_FDPIC:
+      fdpic = true;
+      return 1;
     }
 
   return 0;
@@ -219,7 +227,8 @@ md_show_usage (FILE * stream)
   fprintf (stream, _("  --mpid\n"));
   fprintf (stream, _("  --mint-register=<value>\n"));
   fprintf (stream, _("  --mcpu=<rx100|rx200|rx600|rx610|rxv2|rxv3|rxv3-dfpu>\n"));
-  fprintf (stream, _("  --mno-allow-string-insns"));
+  fprintf (stream, _("  --mno-allow-string-insns\n"));
+  fprintf (stream, _("  --fdpic"));
 }
 
 static void
@@ -1162,6 +1171,9 @@ rx_parse_name (char const *name, expressionS *exprP,
     { "GOT", BFD_RELOC_32_GOT_PCREL },
     { "PLT", BFD_RELOC_32_PLT_PCREL },
     { "PCREL", BFD_RELOC_32_PCREL },
+    { "GOTFUNCDESC", BFD_RELOC_RX_GOTFUNCDESC },
+    { "GOTOFFFUNCDESC", BFD_RELOC_RX_GOTOFFFUNCDESC },
+    { "FUNCDESC", BFD_RELOC_RX_FUNCDESC },
     { NULL, -1 },
   };
   const struct suffix_list *s;
@@ -1276,7 +1288,8 @@ md_assemble (char * str)
   APPEND (post, n_post);
 
   if (rx_bytes.link_relax && rx_bytes.n_fixups &&
-      rx_bytes.fixups[0].exp.X_add_symbol != GOT_symbol)
+      rx_bytes.fixups[0].exp.X_add_symbol != GOT_symbol &&
+      rx_bytes.fixups[0].exp.X_op != O_PIC_reloc)
     {
       fixS * f;
 
@@ -2207,6 +2220,15 @@ md_convert_frag (bfd *   abfd ATTRIBUTE_UNUSED,
 	      case BFD_RELOC_RX_GOTPC:
 		reloc_type = rxb->fixups[fi].exp.X_md;
 		break;
+	      case BFD_RELOC_RX_GOTFUNCDESC:
+		reloc_type = BFD_RELOC_RX_GOTFUNCDESC;
+		break;
+	      case BFD_RELOC_RX_GOTOFFFUNCDESC:
+		reloc_type = BFD_RELOC_RX_GOTOFFFUNCDESC;
+		break;
+	      case BFD_RELOC_RX_FUNCDESC:
+		reloc_type = BFD_RELOC_RX_FUNCDESC;
+		break;
 	      }
 	  }
 	switch (nbytes)
@@ -2616,6 +2638,9 @@ md_apply_fix (struct fix * f ATTRIBUTE_UNUSED,
       break;
 
     case BFD_RELOC_32_GOT_PCREL:
+    case BFD_RELOC_RX_GOTFUNCDESC:
+    case BFD_RELOC_RX_GOTOFFFUNCDESC:
+    case BFD_RELOC_RX_FUNCDESC:
       memset(op, 0x00, 4);
       break;
 
@@ -2880,7 +2905,10 @@ rx_fix_adjustable (fixS *fixP)
 {
   if (fixP->fx_r_type == BFD_RELOC_32_PLT_PCREL
       || fixP->fx_r_type == BFD_RELOC_32_GOT_PCREL
-      || fixP->fx_r_type == BFD_RELOC_RX_GOTPC)
+      || fixP->fx_r_type == BFD_RELOC_RX_GOTPC
+      || fixP->fx_r_type == BFD_RELOC_RX_GOTFUNCDESC
+      || fixP->fx_r_type == BFD_RELOC_RX_GOTOFFFUNCDESC
+      || fixP->fx_r_type == BFD_RELOC_RX_FUNCDESC)
     return false;
 
   return true;
@@ -2892,6 +2920,9 @@ void
 rx_elf_final_processing (void)
 {
   elf_elfheader (stdoutput)->e_flags |= elf_flags;
+
+  if (fdpic)
+    elf_elfheader (stdoutput)->e_flags |= EF_RX_FDPIC;
 }
 
 /* Scan the current input line for occurrences of Renesas

--- a/include/elf/rx.h
+++ b/include/elf/rx.h
@@ -64,6 +64,10 @@ START_RELOC_NUMBERS (elf_rx_reloc_type)
   RELOC_NUMBER (R_RX_RELATIVE,     0x18)
   RELOC_NUMBER (R_RX_GOTOFF,       0x19)
   RELOC_NUMBER (R_RX_GOTPC,	   0x1a)
+  RELOC_NUMBER (R_RX_GOTFUNCDESC,  0x1b)
+  RELOC_NUMBER (R_RX_GOTOFFFUNCDESC, 0x1c)
+  RELOC_NUMBER (R_RX_FUNCDESC   ,  0x1d)
+  RELOC_NUMBER (R_RX_FUNCDESC_VALUE, 0x1e)
 
   /* These are extensions added by Red Hat.  */
   RELOC_NUMBER (R_RX_RH_3_PCREL,   0x20) /* Like R_RX_DIR8S_PCREL but only 3-bits.  */
@@ -123,6 +127,8 @@ END_RELOC_NUMBERS (R_RX_max)
 #define EF_RX_CPU_RX	0x00000079      /* FIXME: this collides with the E_FLAG_RX_... values below.  */
 #define EF_RX_CPU_MASK	0x000003FF	/* specific cpu bits.  */
 #define EF_RX_ALL_FLAGS	(EF_RX_CPU_MASK)
+#define EF_RX_PIC	0x1000
+#define EF_RX_FDPIC	0x2000
 
 /* Values for the e_flags field in the ELF header.  */
 #define E_FLAG_RX_64BIT_DOUBLES		(1 << 0)