2002-12-12 Alexandre Oliva <aoliva@redhat.com>
authorAlexandre Oliva <aoliva@redhat.com>
Thu, 10 Jul 2003 03:20:00 +0000 (03:20 +0000)
committerAlexandre Oliva <aoliva@redhat.com>
Thu, 10 Jul 2003 03:20:00 +0000 (03:20 +0000)
* elf-m10300.c (elf32_mn10300_link_hash_newfunc): Initialize
pcrel_relocs_copied.
2001-12-13  Alexandre Oliva  <aoliva@redhat.com>
* elf-m10300.c (ELF_DYNAMIC_INTERPRETER): Renamed from
ld-linux.so.2 to ld.so.1.
2001-10-10  Alexandre Oliva  <aoliva@redhat.com>
* elf-m10300.c (elf_mn10300_sizeof_plt0): New macro.
(_bfd_mn10300_elf_adjust_dynamic_symbol): Use it.
(_bfd_mn10300_elf_finish_dynamic_symbol): Likewise.
* elf-m10300.c (_bfd_mn10300_elf_size_dynamic_sections): Allocate
.rela.* section contents with bfd_zalloc.
2001-09-25  Alexandre Oliva  <aoliva@redhat.com>
* elf-m10300.c: Added declarations for functions missing them.
Merge some shared-library changes from the i386 back-end.  Use
R_MN10300_RELATIVE instead of R_MN10300_PCREL32 and
R_MN10300_GLOB_DAT instead of R_MN10300_32 where appropriate.
(struct elf32_mn10300_link_hash_entry): Remove duplicates of
members of elf_link_hash_entry.  Adjusted references.
(mn10300_elf_final_link_relocate): dynobj was already loaded
into a local variable, use it.
2001-09-21  Nick Clifton  <nickc@cambridge.redhat.com>
* elf-m10300.c: Add missing function prototypes.
2001-08-24  Alexandre Oliva  <aoliva@redhat.com>
* elf-m10300.c (mn10300_elf_relocate_section): Don't compute
relocation for dynamic relocations.
2001-05-16  Alexandre Oliva  <aoliva@redhat.com>
* reloc.c (BFD_RELOC_MN10300_GOTOFF24): New.
* elf-m10300.c: Introduce GOTPC16, GOTOFF24, GOTOFF16 and
PLT16, and rename GOTPC to GOTPC32 and GOTOFF to GOTOFF32.
(_bfd_mn10300_elf_create_dynamic_sections): Move creation ot PLT...
(_bfd_mn10300_elf_create_got_section): ... here, so that its
adress is already known at the time we compute relaxations.
(mn10300_elf_relax_section): Relax GOTPC32, GOTOFF32, GOT32
and PLT32 to narrower relocations.
* libbfd.h, bfd-in2.h: Rebuilt.
2001-04-12  Alexandre Oliva  <aoliva@redhat.com>
* reloc.c (BFD_RELOC_MN10300_GOT32, BFD_RELOC_MN10300_GOT24,
BFD_RELOC_MN10300_GOT16, BFD_RELOC_MN10300_COPY,
BFD_RELOC_MN10300_GLOB_DAT, BFD_RELOC_MN10300_JMP_SLOT,
BFD_RELOC_MN10300_RELATIVE): New relocs.
* libbfd.h, bfd-in2.h: Rebuilt.
* elf-m10300.c (struct elf_mn10300_pcrel_relocs_copied): New.
(struct elf32_mn10300_link_hash_entry): Added DSO-related
fields.
(elf_mn10300_howto): Defined new relocation types.
(mn10300_reloc_map): Map them.
(_bfd_mn10300_elf_create_got_section): New fn.
(mn10300_elf_check_relocs): Handle PIC relocs.
(mn10300_elf_final_link_relocate): Likewise.
(mn10300_elf_relocate_section): Handle DSOs.
(PLT0_ENTRY_SIZE, PLT_ENTRY_SIZE, PIC_PLT_ENTRY_SIZE): New macros.
(elf_mn10300_plt0_entry, elf_mn10300_plt_entry,
elf_mn10300_pic_plt_entry): New.
(elf_mn10300_sizeof_plt, elf_mn10300_plt_plt0_offset,
elf_mn10300_plt0_linker_offset, elf_mn10300_plt0_gotid_offset,
elf_mn10300_plt_temp_offset, elf_mn10300_plt_symbol_offset,
elf_mn10300_plt_reloc_offset: New macros.
(ELF_DYNAMIC_INTERPRETER): Likewise.
(_bfd_mn10300_elf_create_dynamic_sections): New function.
(_bfd_mn10300_elf_adjust_dynamic_symbol): Likewise.
(_bfd_mn10300_elf_discard_copies): Likewise.
(_bfd_mn10300_elf_size_dynamic_sections): Likewise.
(_bfd_mn10300_elf_finish_dynamic_symbol): Likewise.
(_bfd_mn10300_elf_finish_dynamic_sections): Likewise.
(elf_backend_can_gc_sections,
elf_backend_create_dynamic_sections,
elf_backend_adjust_dynamic_sections,
elf_backend_size_dynamic_sections,
elf_backend_finish_dynamic_symbol,
elf_backend_finish_dynamic_sections, elf_backend_want_got_plt,
elf_backend_plt_readonly, elf_backend_want_plt_sym,
elf_backend_got_header_size, elf_backend_plt_header_size): New
macros.

bfd/ChangeLog
bfd/bfd-in2.h
bfd/elf-m10300.c
bfd/libbfd.h
bfd/reloc.c

index 1a38a7b..1d42a44 100644 (file)
@@ -1,5 +1,82 @@
 2003-07-09  Alexandre Oliva  <aoliva@redhat.com>
 
+       2002-12-12  Alexandre Oliva  <aoliva@redhat.com>
+       * elf-m10300.c (elf32_mn10300_link_hash_newfunc): Initialize
+       pcrel_relocs_copied.
+       2001-12-13  Alexandre Oliva  <aoliva@redhat.com>
+       * elf-m10300.c (ELF_DYNAMIC_INTERPRETER): Renamed from
+       ld-linux.so.2 to ld.so.1.
+       2001-10-10  Alexandre Oliva  <aoliva@redhat.com>
+       * elf-m10300.c (elf_mn10300_sizeof_plt0): New macro.
+       (_bfd_mn10300_elf_adjust_dynamic_symbol): Use it.
+       (_bfd_mn10300_elf_finish_dynamic_symbol): Likewise.
+       * elf-m10300.c (_bfd_mn10300_elf_size_dynamic_sections): Allocate
+       .rela.* section contents with bfd_zalloc.
+       2001-09-25  Alexandre Oliva  <aoliva@redhat.com>
+       * elf-m10300.c: Added declarations for functions missing them.
+       Merge some shared-library changes from the i386 back-end.  Use
+       R_MN10300_RELATIVE instead of R_MN10300_PCREL32 and
+       R_MN10300_GLOB_DAT instead of R_MN10300_32 where appropriate.
+       (struct elf32_mn10300_link_hash_entry): Remove duplicates of
+       members of elf_link_hash_entry.  Adjusted references.
+       (mn10300_elf_final_link_relocate): dynobj was already loaded
+       into a local variable, use it.
+       2001-09-21  Nick Clifton  <nickc@cambridge.redhat.com>
+       * elf-m10300.c: Add missing function prototypes.
+       2001-08-24  Alexandre Oliva  <aoliva@redhat.com>
+       * elf-m10300.c (mn10300_elf_relocate_section): Don't compute
+       relocation for dynamic relocations.
+       2001-05-16  Alexandre Oliva  <aoliva@redhat.com>
+       * reloc.c (BFD_RELOC_MN10300_GOTOFF24): New.
+       * elf-m10300.c: Introduce GOTPC16, GOTOFF24, GOTOFF16 and
+       PLT16, and rename GOTPC to GOTPC32 and GOTOFF to GOTOFF32.
+       (_bfd_mn10300_elf_create_dynamic_sections): Move creation ot PLT...
+       (_bfd_mn10300_elf_create_got_section): ... here, so that its
+       adress is already known at the time we compute relaxations.
+       (mn10300_elf_relax_section): Relax GOTPC32, GOTOFF32, GOT32
+       and PLT32 to narrower relocations.
+       * libbfd.h, bfd-in2.h: Rebuilt.
+       2001-04-12  Alexandre Oliva  <aoliva@redhat.com>
+       * reloc.c (BFD_RELOC_MN10300_GOT32, BFD_RELOC_MN10300_GOT24,
+       BFD_RELOC_MN10300_GOT16, BFD_RELOC_MN10300_COPY,
+       BFD_RELOC_MN10300_GLOB_DAT, BFD_RELOC_MN10300_JMP_SLOT,
+       BFD_RELOC_MN10300_RELATIVE): New relocs.
+       * libbfd.h, bfd-in2.h: Rebuilt.
+       * elf-m10300.c (struct elf_mn10300_pcrel_relocs_copied): New.
+       (struct elf32_mn10300_link_hash_entry): Added DSO-related
+       fields.
+       (elf_mn10300_howto): Defined new relocation types.
+       (mn10300_reloc_map): Map them.
+       (_bfd_mn10300_elf_create_got_section): New fn.
+       (mn10300_elf_check_relocs): Handle PIC relocs.
+       (mn10300_elf_final_link_relocate): Likewise.
+       (mn10300_elf_relocate_section): Handle DSOs.
+       (PLT0_ENTRY_SIZE, PLT_ENTRY_SIZE, PIC_PLT_ENTRY_SIZE): New macros.
+       (elf_mn10300_plt0_entry, elf_mn10300_plt_entry,
+       elf_mn10300_pic_plt_entry): New.
+       (elf_mn10300_sizeof_plt, elf_mn10300_plt_plt0_offset,
+       elf_mn10300_plt0_linker_offset, elf_mn10300_plt0_gotid_offset,
+       elf_mn10300_plt_temp_offset, elf_mn10300_plt_symbol_offset,
+       elf_mn10300_plt_reloc_offset: New macros.
+       (ELF_DYNAMIC_INTERPRETER): Likewise.
+       (_bfd_mn10300_elf_create_dynamic_sections): New function.
+       (_bfd_mn10300_elf_adjust_dynamic_symbol): Likewise.
+       (_bfd_mn10300_elf_discard_copies): Likewise.
+       (_bfd_mn10300_elf_size_dynamic_sections): Likewise.
+       (_bfd_mn10300_elf_finish_dynamic_symbol): Likewise.
+       (_bfd_mn10300_elf_finish_dynamic_sections): Likewise.
+       (elf_backend_can_gc_sections,
+       elf_backend_create_dynamic_sections,
+       elf_backend_adjust_dynamic_sections,
+       elf_backend_size_dynamic_sections,
+       elf_backend_finish_dynamic_symbol,
+       elf_backend_finish_dynamic_sections, elf_backend_want_got_plt,
+       elf_backend_plt_readonly, elf_backend_want_plt_sym,
+       elf_backend_got_header_size, elf_backend_plt_header_size): New
+       macros.
+
+2003-07-09  Alexandre Oliva  <aoliva@redhat.com>
+
        2001-05-06  Alexandre Oliva  <aoliva@redhat.com>
        * elf-m10300.c (compute_function_info): Account for AM33
        registers in `movm' when computing stack space for `call' when
index 171a24c..e8151d6 100644 (file)
@@ -2329,6 +2329,33 @@ to compensate for the borrow when the low bits are added.  */
   BFD_RELOC_FRV_GPRELHI,
   BFD_RELOC_FRV_GPRELLO,
 
+/* This is a 24bit GOT-relative reloc for the mn10300.  */
+  BFD_RELOC_MN10300_GOTOFF24,
+
+/* This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes
+in the instruction.  */
+  BFD_RELOC_MN10300_GOT32,
+
+/* This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes
+in the instruction.  */
+  BFD_RELOC_MN10300_GOT24,
+
+/* This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes
+in the instruction.  */
+  BFD_RELOC_MN10300_GOT16,
+
+/* Copy symbol at runtime.  */
+  BFD_RELOC_MN10300_COPY,
+
+/* Create GOT entry.  */
+  BFD_RELOC_MN10300_GLOB_DAT,
+
+/* Create PLT entry.  */
+  BFD_RELOC_MN10300_JMP_SLOT,
+
+/* Adjust by program base.  */
+  BFD_RELOC_MN10300_RELATIVE,
+
 
 /* i386/elf relocations  */
   BFD_RELOC_386_GOT32,
index d33c859..7591833 100644 (file)
@@ -26,7 +26,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 static bfd_reloc_status_type mn10300_elf_final_link_relocate
   PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
-          bfd_vma, bfd_vma, bfd_vma, struct bfd_link_info *,
+          bfd_vma, bfd_vma, bfd_vma,
+          struct elf_link_hash_entry *, unsigned long, struct bfd_link_info *,
           asection *, int));
 static bfd_boolean mn10300_elf_relocate_section
   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
@@ -45,6 +46,25 @@ bfd_boolean _bfd_mn10300_elf_object_p
 bfd_boolean _bfd_mn10300_elf_merge_private_bfd_data
   PARAMS ((bfd *,bfd *));
 
+/* The mn10300 linker needs to keep track of the number of relocs that
+   it decides to copy in check_relocs for each symbol.  This is so
+   that it can discard PC relative relocs if it doesn't need them when
+   linking with -Bsymbolic.  We store the information in a field
+   extending the regular ELF linker hash table.  */
+
+/* This structure keeps track of the number of PC relative relocs we
+   have copied for a given symbol.  */
+
+struct elf_mn10300_pcrel_relocs_copied
+{
+  /* Next section.  */
+  struct elf_mn10300_pcrel_relocs_copied * next;
+  /* A section in dynobj.  */
+  asection * section;
+  /* Number of relocs copied in this section.  */
+  bfd_size_type count;
+};
+
 struct elf32_mn10300_link_hash_entry {
   /* The basic elf link hash table entry.  */
   struct elf_link_hash_entry root;
@@ -70,6 +90,9 @@ struct elf32_mn10300_link_hash_entry {
      add it to the hash table to avoid computing it over and over.  */
   unsigned char movm_stack_size;
 
+  /* Number of PC relative relocs copied for this symbol.  */
+  struct elf_mn10300_pcrel_relocs_copied * pcrel_relocs_copied;
+
 /* When set, convert all "call" instructions to this target into "calls"
    instructions.  */
 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
@@ -137,6 +160,23 @@ static void compute_function_info
   PARAMS ((bfd *, struct elf32_mn10300_link_hash_entry *,
           bfd_vma, unsigned char *));
 
+static bfd_boolean _bfd_mn10300_elf_create_got_section
+  PARAMS ((bfd *, struct bfd_link_info *));
+static bfd_boolean _bfd_mn10300_elf_create_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static bfd_boolean _bfd_mn10300_elf_adjust_dynamic_symbol
+  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+static bfd_boolean _bfd_mn10300_elf_discard_copies
+  PARAMS ((struct elf32_mn10300_link_hash_entry *,
+          struct bfd_link_info *));
+static bfd_boolean _bfd_mn10300_elf_size_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+static bfd_boolean _bfd_mn10300_elf_finish_dynamic_symbol
+  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
+          Elf_Internal_Sym *));
+static bfd_boolean _bfd_mn10300_elf_finish_dynamic_sections
+  PARAMS ((bfd *, struct bfd_link_info *));
+
 static reloc_howto_type elf_mn10300_howto_table[] = {
   /* Dummy relocation.  Does nothing.  */
   HOWTO (R_MN10300_NONE,
@@ -281,6 +321,202 @@ static reloc_howto_type elf_mn10300_howto_table[] = {
         0xffffff,
         0xffffff,
         FALSE),
+  HOWTO (R_MN10300_GOTPC32,    /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        32,                    /* bitsize */
+        TRUE,                  /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GOTPC32",   /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        TRUE),                 /* pcrel_offset */
+
+  HOWTO (R_MN10300_GOTPC16,    /* type */
+        0,                     /* rightshift */
+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
+        16,                    /* bitsize */
+        TRUE,                  /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GOTPC16",   /* name */
+        FALSE,                 /* partial_inplace */
+        0xffff,                /* src_mask */
+        0xffff,                /* dst_mask */
+        TRUE),                 /* pcrel_offset */
+
+  HOWTO (R_MN10300_GOTOFF32,   /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        32,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GOTOFF32",  /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_GOTOFF24,   /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        24,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GOTOFF24",  /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffff,              /* src_mask */
+        0xffffff,              /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_GOTOFF16,   /* type */
+        0,                     /* rightshift */
+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
+        16,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GOTOFF16",  /* name */
+        FALSE,                 /* partial_inplace */
+        0xffff,                /* src_mask */
+        0xffff,                /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_PLT32,      /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        32,                    /* bitsize */
+        TRUE,                  /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_PLT32",     /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        TRUE),                 /* pcrel_offset */
+
+  HOWTO (R_MN10300_PLT16,      /* type */
+        0,                     /* rightshift */
+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
+        16,                    /* bitsize */
+        TRUE,                  /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_PLT16",     /* name */
+        FALSE,                 /* partial_inplace */
+        0xffff,                /* src_mask */
+        0xffff,                /* dst_mask */
+        TRUE),                 /* pcrel_offset */
+
+  HOWTO (R_MN10300_GOT32,      /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        32,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GOT32",     /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_GOT24,      /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        24,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GOT24",     /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_GOT16,      /* type */
+        0,                     /* rightshift */
+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
+        16,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GOT16",     /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_COPY,       /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        32,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_COPY",              /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_GLOB_DAT,   /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        32,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_GLOB_DAT",  /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_JMP_SLOT,   /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        32,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_JMP_SLOT",  /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_RELATIVE,   /* type */
+        0,                     /* rightshift */
+        2,                     /* size (0 = byte, 1 = short, 2 = long) */
+        32,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_bitfield, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* */
+        "R_MN10300_RELATIVE",  /* name */
+        FALSE,                 /* partial_inplace */
+        0xffffffff,            /* src_mask */
+        0xffffffff,            /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
 };
 
 struct mn10300_reloc_map {
@@ -299,8 +535,130 @@ static const struct mn10300_reloc_map mn10300_reloc_map[] = {
   { BFD_RELOC_24, R_MN10300_24, },
   { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
   { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
+  { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
+  { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
+  { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
+  { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
+  { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
+  { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
+  { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
+  { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
+  { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
+  { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
+  { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
+  { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
+  { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
+  { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
 };
 
+/* Create the GOT section.  */
+
+static bfd_boolean
+_bfd_mn10300_elf_create_got_section (abfd, info)
+     bfd * abfd;
+     struct bfd_link_info * info;
+{
+  flagword   flags;
+  flagword   pltflags;
+  asection * s;
+  struct elf_link_hash_entry * h;
+  struct elf_backend_data *    bed = get_elf_backend_data (abfd);
+  int ptralign;
+
+  /* This function may be called more than once.  */
+  if (bfd_get_section_by_name (abfd, ".got") != NULL)
+    return TRUE;
+
+  switch (bed->s->arch_size)
+    {
+    case 32:
+      ptralign = 2;
+      break;
+
+    case 64:
+      ptralign = 3;
+      break;
+
+    default:
+      bfd_set_error (bfd_error_bad_value);
+      return FALSE;
+    }
+
+  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
+          | SEC_LINKER_CREATED);
+
+  pltflags = flags;
+  pltflags |= SEC_CODE;
+  if (bed->plt_not_loaded)
+    pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
+  if (bed->plt_readonly)
+    pltflags |= SEC_READONLY;
+
+  s = bfd_make_section (abfd, ".plt");
+  if (s == NULL
+      || ! bfd_set_section_flags (abfd, s, pltflags)
+      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
+    return FALSE;
+
+  if (bed->want_plt_sym)
+    {
+      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
+        .plt section.  */
+      struct elf_link_hash_entry *h = NULL;
+      if (! (_bfd_generic_link_add_one_symbol
+            (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
+             (bfd_vma) 0, (const char *) NULL, FALSE,
+             get_elf_backend_data (abfd)->collect,
+             (struct bfd_link_hash_entry **) &h)))
+       return FALSE;
+      h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
+      h->type = STT_OBJECT;
+
+      if (info->shared
+         && ! _bfd_elf_link_record_dynamic_symbol (info, h))
+       return FALSE;
+    }
+
+  s = bfd_make_section (abfd, ".got");
+  if (s == NULL
+      || ! bfd_set_section_flags (abfd, s, flags)
+      || ! bfd_set_section_alignment (abfd, s, ptralign))
+    return FALSE;
+
+  if (bed->want_got_plt)
+    {
+      s = bfd_make_section (abfd, ".got.plt");
+      if (s == NULL
+         || ! bfd_set_section_flags (abfd, s, flags)
+         || ! bfd_set_section_alignment (abfd, s, ptralign))
+       return FALSE;
+    }
+
+  /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
+     (or .got.plt) section.  We don't do this in the linker script
+     because we don't want to define the symbol if we are not creating
+     a global offset table.  */
+  h = NULL;
+  if (!(_bfd_generic_link_add_one_symbol
+       (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
+        bed->got_symbol_offset, (const char *) NULL, FALSE,
+        bed->collect, (struct bfd_link_hash_entry **) &h)))
+    return FALSE;
+  h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
+  h->type = STT_OBJECT;
+
+  if (info->shared
+      && ! _bfd_elf_link_record_dynamic_symbol (info, h))
+    return FALSE;
+
+  elf_hash_table (info)->hgot = h;
+
+  /* The first bit of the global offset table is the header.  */
+  s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
+
+  return TRUE;
+}
+
 static reloc_howto_type *
 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
      bfd *abfd ATTRIBUTE_UNUSED;
@@ -349,6 +707,15 @@ mn10300_elf_check_relocs (abfd, info, sec, relocs)
   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
   const Elf_Internal_Rela *rel;
   const Elf_Internal_Rela *rel_end;
+  bfd *      dynobj;
+  bfd_vma *  local_got_offsets;
+  asection * sgot;
+  asection * srelgot;
+  asection * sreloc;
+
+  sgot    = NULL;
+  srelgot = NULL;
+  sreloc  = NULL;
 
   if (info->relocatable)
     return TRUE;
@@ -359,6 +726,8 @@ mn10300_elf_check_relocs (abfd, info, sec, relocs)
   if (!elf_bad_symtab (abfd))
     sym_hashes_end -= symtab_hdr->sh_info;
 
+  dynobj = elf_hash_table (info)->dynobj;
+  local_got_offsets = elf_local_got_offsets (abfd);
   rel_end = relocs + sec->reloc_count;
   for (rel = relocs; rel < rel_end; rel++)
     {
@@ -371,6 +740,29 @@ mn10300_elf_check_relocs (abfd, info, sec, relocs)
       else
        h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 
+      /* Some relocs require a global offset table.  */
+      if (dynobj == NULL)
+       {
+         switch (ELF32_R_TYPE (rel->r_info))
+           {
+           case R_MN10300_GOT32:
+           case R_MN10300_GOT24:
+           case R_MN10300_GOT16:
+           case R_MN10300_GOTOFF32:
+           case R_MN10300_GOTOFF24:
+           case R_MN10300_GOTOFF16:
+           case R_MN10300_GOTPC32:
+           case R_MN10300_GOTPC16:
+             elf_hash_table (info)->dynobj = dynobj = abfd;
+             if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
+               return FALSE;
+             break;
+
+           default:
+             break;
+           }
+       }
+
       switch (ELF32_R_TYPE (rel->r_info))
        {
        /* This relocation describes the C++ object vtable hierarchy.
@@ -386,6 +778,221 @@ mn10300_elf_check_relocs (abfd, info, sec, relocs)
          if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
            return FALSE;
          break;
+       case R_MN10300_GOT32:
+       case R_MN10300_GOT24:
+       case R_MN10300_GOT16:
+         /* This symbol requires a global offset table entry.  */
+
+         if (sgot == NULL)
+           {
+             sgot = bfd_get_section_by_name (dynobj, ".got");
+             BFD_ASSERT (sgot != NULL);
+           }
+
+         if (srelgot == NULL
+             && (h != NULL || info->shared))
+           {
+             srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+             if (srelgot == NULL)
+               {
+                 srelgot = bfd_make_section (dynobj, ".rela.got");
+                 if (srelgot == NULL
+                     || ! bfd_set_section_flags (dynobj, srelgot,
+                                                 (SEC_ALLOC
+                                                  | SEC_LOAD
+                                                  | SEC_HAS_CONTENTS
+                                                  | SEC_IN_MEMORY
+                                                  | SEC_LINKER_CREATED
+                                                  | SEC_READONLY))
+                     || ! bfd_set_section_alignment (dynobj, srelgot, 2))
+                   return FALSE;
+               }
+           }
+
+         if (h != NULL)
+           {
+             if (h->got.offset != (bfd_vma) -1)
+               /* We have already allocated space in the .got.  */
+               break;
+
+             h->got.offset = sgot->_raw_size;
+
+             /* 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;
+               }
+
+             srelgot->_raw_size += sizeof (Elf32_External_Rela);
+           }
+         else
+           {
+             /* This is a global offset table entry for a local
+                symbol.  */
+             if (local_got_offsets == NULL)
+               {
+                 size_t       size;
+                 unsigned int i;
+
+                 size = symtab_hdr->sh_info * sizeof (bfd_vma);
+                 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
+
+                 if (local_got_offsets == NULL)
+                   return FALSE;
+                 elf_local_got_offsets (abfd) = local_got_offsets;
+
+                 for (i = 0; i < symtab_hdr->sh_info; i++)
+                   local_got_offsets[i] = (bfd_vma) -1;
+               }
+
+             if (local_got_offsets[r_symndx] != (bfd_vma) -1)
+               /* We have already allocated space in the .got.  */
+               break;
+
+             local_got_offsets[r_symndx] = sgot->_raw_size;
+
+             if (info->shared)
+               /* If we are generating a shared object, we need to
+                  output a R_MN10300_RELATIVE reloc so that the dynamic
+                  linker can adjust this GOT entry.  */
+               srelgot->_raw_size += sizeof (Elf32_External_Rela);
+           }
+
+         sgot->_raw_size += 4;
+
+         break;
+
+       case R_MN10300_PLT32:
+       case R_MN10300_PLT16:
+         /* This symbol requires a procedure linkage table entry.  We
+            actually build the entry in adjust_dynamic_symbol,
+            because this might be a case of linking PIC code which is
+            never referenced by a dynamic object, in which case we
+            don't need to generate a procedure linkage table entry
+            after all.  */
+
+         /* If this is a local symbol, we resolve it directly without
+            creating a procedure linkage table entry.  */
+         if (h == NULL)
+           continue;
+
+         if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
+             || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
+           break;
+
+         h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
+
+         break;
+
+       case R_MN10300_32:
+       case R_MN10300_24:
+       case R_MN10300_16:
+       case R_MN10300_8:
+       case R_MN10300_PCREL32:
+       case R_MN10300_PCREL16:
+       case R_MN10300_PCREL8:
+         if (h != NULL)
+           h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
+
+         /* If we are creating a shared library, and this is a reloc
+            against a global symbol, or a non PC relative reloc
+            against a local symbol, then we need to copy the reloc
+            into the shared library.  However, if we are linking with
+            -Bsymbolic, we do not need to copy a reloc against a
+            global symbol which is defined in an object we are
+            including in the link (i.e., DEF_REGULAR is set).  At
+            this point we have not seen all the input files, so it is
+            possible that DEF_REGULAR is not set now but will be set
+            later (it is never cleared).  We account for that
+            possibility below by storing information in the
+            pcrel_relocs_copied field of the hash table entry.  */
+         if (info->shared
+             && (sec->flags & SEC_ALLOC) != 0
+             && (! (elf_mn10300_howto_table[ELF32_R_TYPE (rel->r_info)]
+                    .pc_relative)
+                 || (h != NULL
+                     && (! info->symbolic
+                         || h->root.type == bfd_link_hash_defweak
+                         || (h->elf_link_hash_flags
+                             & ELF_LINK_HASH_DEF_REGULAR) == 0))))
+           {
+             /* When creating a shared object, we must copy these
+                reloc types into the output file.  We create a reloc
+                section in dynobj and make room for this reloc.  */
+             if (sreloc == NULL)
+               {
+                 const char * name;
+
+                 name = (bfd_elf_string_from_elf_section
+                         (abfd,
+                          elf_elfheader (abfd)->e_shstrndx,
+                          elf_section_data (sec)->rel_hdr.sh_name));
+                 if (name == NULL)
+                   return FALSE;
+
+                 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
+                             && strcmp (bfd_get_section_name (abfd, sec),
+                                        name + 5) == 0);
+
+                 sreloc = bfd_get_section_by_name (dynobj, name);
+                 if (sreloc == NULL)
+                   {
+                     flagword flags;
+
+                     sreloc = bfd_make_section (dynobj, name);
+                     flags = (SEC_HAS_CONTENTS | SEC_READONLY
+                              | SEC_IN_MEMORY | SEC_LINKER_CREATED);
+                     if ((sec->flags & SEC_ALLOC) != 0)
+                       flags |= SEC_ALLOC | SEC_LOAD;
+                     if (sreloc == NULL
+                         || ! bfd_set_section_flags (dynobj, sreloc, flags)
+                         || ! bfd_set_section_alignment (dynobj, sreloc, 2))
+                       return FALSE;
+                   }
+               }
+
+             sreloc->_raw_size += sizeof (Elf32_External_Rela);
+
+             /* If we are linking with -Bsymbolic, and this is a
+                global symbol, we count the number of PC relative
+                relocations we have entered for this symbol, so that
+                we can discard them again if the symbol is later
+                defined by a regular object.  Note that this function
+                is only called if we are using an elf_sh linker
+                hash table, which means that h is really a pointer to
+                an elf32_mn10300_link_hash_entry.  */
+             if (h != NULL
+                 && (elf_mn10300_howto_table[ELF32_R_TYPE (rel->r_info)]
+                     .pc_relative))
+               {
+                 struct elf32_mn10300_link_hash_entry *eh;
+                 struct elf_mn10300_pcrel_relocs_copied *p;
+
+                 eh = (struct elf32_mn10300_link_hash_entry *) h;
+
+                 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
+                   if (p->section == sreloc)
+                     break;
+
+                 if (p == NULL)
+                   {
+                     p = ((struct elf_mn10300_pcrel_relocs_copied *)
+                          bfd_alloc (dynobj, sizeof *p));
+                     if (p == NULL)
+                       return FALSE;
+
+                     p->next = eh->pcrel_relocs_copied;
+                     eh->pcrel_relocs_copied = p;
+                     p->section = sreloc;
+                     p->count = 0;
+                   }
+
+                 ++p->count;
+               }
+           }
+
+         break;
        }
     }
 
@@ -436,7 +1043,7 @@ mn10300_elf_gc_mark_hook (sec, info, rel, h, sym)
 static bfd_reloc_status_type
 mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
                                 input_section, contents, offset, value,
-                                addend, info, sym_sec, is_local)
+                                addend, h, symndx, info, sym_sec, is_local)
      reloc_howto_type *howto;
      bfd *input_bfd;
      bfd *output_bfd ATTRIBUTE_UNUSED;
@@ -445,12 +1052,26 @@ mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
      bfd_vma offset;
      bfd_vma value;
      bfd_vma addend;
+     struct elf_link_hash_entry * h;
+     unsigned long symndx;
      struct bfd_link_info *info ATTRIBUTE_UNUSED;
      asection *sym_sec ATTRIBUTE_UNUSED;
      int is_local ATTRIBUTE_UNUSED;
 {
   unsigned long r_type = howto->type;
   bfd_byte *hit_data = contents + offset;
+  bfd *      dynobj;
+  bfd_vma *  local_got_offsets;
+  asection * sgot;
+  asection * splt;
+  asection * sreloc;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  local_got_offsets = elf_local_got_offsets (input_bfd);
+
+  sgot   = NULL;
+  splt   = NULL;
+  sreloc = NULL;
 
   switch (r_type)
     {
@@ -458,6 +1079,97 @@ mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
       return bfd_reloc_ok;
 
     case R_MN10300_32:
+      if (info->shared
+         && (input_section->flags & SEC_ALLOC) != 0)
+       {
+         Elf_Internal_Rela outrel;
+         bfd_boolean skip, relocate;
+
+         /* When generating a shared object, these relocations are
+            copied into the output file to be resolved at run
+            time.  */
+         if (sreloc == NULL)
+           {
+             const char * name;
+
+             name = (bfd_elf_string_from_elf_section
+                     (input_bfd,
+                      elf_elfheader (input_bfd)->e_shstrndx,
+                      elf_section_data (input_section)->rel_hdr.sh_name));
+             if (name == NULL)
+               return FALSE;
+
+             BFD_ASSERT (strncmp (name, ".rela", 5) == 0
+                         && strcmp (bfd_get_section_name (input_bfd,
+                                                          input_section),
+                                    name + 5) == 0);
+
+             sreloc = bfd_get_section_by_name (dynobj, name);
+             BFD_ASSERT (sreloc != NULL);
+           }
+
+         skip = FALSE;
+
+         if (elf_section_data (input_section)->sec_info == NULL
+             || (input_section->sec_info_type != ELF_INFO_TYPE_STABS))
+           outrel.r_offset = offset;
+         else
+           {
+             bfd_vma off;
+
+             off = (_bfd_stab_section_offset
+                    (output_bfd, & elf_hash_table (info)->stab_info,
+                     input_section,
+                     & elf_section_data (input_section)->sec_info,
+                     offset));
+             if (off == (bfd_vma) -1)
+               skip = TRUE;
+             outrel.r_offset = off;
+           }
+
+         outrel.r_offset += (input_section->output_section->vma
+                             + input_section->output_offset);
+
+         if (skip)
+           {
+             memset (&outrel, 0, sizeof outrel);
+             relocate = FALSE;
+           }
+         else
+           {
+             /* h->dynindx may be -1 if this symbol was marked to
+                become local.  */
+             if (h == NULL
+                 || ((info->symbolic || h->dynindx == -1)
+                     && (h->elf_link_hash_flags
+                         & ELF_LINK_HASH_DEF_REGULAR) != 0))
+               {
+                 relocate = TRUE;
+                 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
+                 outrel.r_addend = value + addend;
+               }
+             else
+               {
+                 BFD_ASSERT (h->dynindx != -1);
+                 relocate = FALSE;
+                 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
+                 outrel.r_addend = value + addend;
+               }
+           }
+
+         bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+                                    (((Elf32_External_Rela *)
+                                      sreloc->contents)
+                                     + sreloc->reloc_count));
+         ++sreloc->reloc_count;
+
+         /* 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)
+           return bfd_reloc_ok;
+       }
       value += addend;
       bfd_put_32 (input_bfd, value, hit_data);
       return bfd_reloc_ok;
@@ -516,6 +1228,81 @@ mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
       return bfd_reloc_ok;
 
     case R_MN10300_PCREL32:
+      if (info->shared
+         && (input_section->flags & SEC_ALLOC) != 0
+         && h != NULL
+         && h->dynindx != -1
+         && (! info->symbolic
+             || (h->elf_link_hash_flags
+                 & ELF_LINK_HASH_DEF_REGULAR) == 0))
+       {
+         Elf_Internal_Rela outrel;
+         bfd_boolean skip;
+
+         /* When generating a shared object, these relocations
+            are copied into the output file to be resolved at run
+            time.  */
+
+         if (sreloc == NULL)
+           {
+             const char * name;
+
+             name = (bfd_elf_string_from_elf_section
+                     (input_bfd,
+                      elf_elfheader (input_bfd)->e_shstrndx,
+                      elf_section_data (input_section)->rel_hdr.sh_name));
+             if (name == NULL)
+               return FALSE;
+
+             BFD_ASSERT (strncmp (name, ".rela", 5) == 0
+                         && strcmp (bfd_get_section_name (input_bfd,
+                                                          input_section),
+                                    name + 5) == 0);
+
+             sreloc = bfd_get_section_by_name (dynobj, name);
+             BFD_ASSERT (sreloc != NULL);
+           }
+
+         skip = FALSE;
+
+         if (elf_section_data (input_section)->sec_info == NULL
+             || (input_section->sec_info_type != ELF_INFO_TYPE_STABS))
+           outrel.r_offset = offset;
+         else
+           {
+             bfd_vma off;
+
+             off = (_bfd_stab_section_offset
+                    (output_bfd, & elf_hash_table (info)->stab_info,
+                     input_section,
+                     & elf_section_data (input_section)->sec_info,
+                     offset));
+             if (off == (bfd_vma) -1)
+               skip = TRUE;
+             outrel.r_offset = off;
+           }
+
+         outrel.r_offset += (input_section->output_section->vma
+                             + input_section->output_offset);
+
+         if (skip)
+           memset (&outrel, 0, sizeof outrel);
+         else
+           {
+             BFD_ASSERT (h != NULL && h->dynindx != -1);
+             outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_PCREL32);
+             outrel.r_addend = addend;
+           }
+
+         bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+                                    (((Elf32_External_Rela *)
+                                      sreloc->contents)
+                                     + sreloc->reloc_count));
+         ++sreloc->reloc_count;
+
+         return bfd_reloc_ok;
+       }
+
       value -= (input_section->output_section->vma
                + input_section->output_offset);
       value -= offset;
@@ -528,6 +1315,208 @@ mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
     case R_MN10300_GNU_VTENTRY:
       return bfd_reloc_ok;
 
+    case R_MN10300_GOTPC32:
+      /* Use global offset table as symbol value.  */
+
+      value = bfd_get_section_by_name (dynobj,
+                                      ".got")->output_section->vma;
+      value -= (input_section->output_section->vma
+               + input_section->output_offset);
+      value -= offset;
+      value += addend;
+
+      bfd_put_32 (input_bfd, value, hit_data);
+      return bfd_reloc_ok;
+      
+    case R_MN10300_GOTPC16:
+      /* Use global offset table as symbol value.  */
+
+      value = bfd_get_section_by_name (dynobj,
+                                      ".got")->output_section->vma;
+      value -= (input_section->output_section->vma
+               + input_section->output_offset);
+      value -= offset;
+      value += addend;
+
+      if ((long) value > 0xffff || (long) value < -0x10000)
+       return bfd_reloc_overflow;
+
+      bfd_put_16 (input_bfd, value, hit_data);
+      return bfd_reloc_ok;
+
+    case R_MN10300_GOTOFF32:
+      value -= bfd_get_section_by_name (dynobj,
+                                       ".got")->output_section->vma;
+      value += addend;
+      
+      bfd_put_32 (input_bfd, value, hit_data);
+      return bfd_reloc_ok;
+
+    case R_MN10300_GOTOFF24:
+      value -= bfd_get_section_by_name (dynobj,
+                                       ".got")->output_section->vma;
+      value += addend;
+      
+      if ((long) value > 0x7fffff || (long) value < -0x800000)
+       return bfd_reloc_overflow;
+
+      bfd_put_8 (input_bfd, value, hit_data);
+      bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
+      bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
+      return bfd_reloc_ok;
+
+    case R_MN10300_GOTOFF16:
+      value -= bfd_get_section_by_name (dynobj,
+                                       ".got")->output_section->vma;
+      value += addend;
+      
+      if ((long) value > 0xffff || (long) value < -0x10000)
+       return bfd_reloc_overflow;
+
+      bfd_put_16 (input_bfd, value, hit_data);
+      return bfd_reloc_ok;
+
+    case R_MN10300_PLT32:
+      if (h != NULL
+         && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
+         && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
+         && h->plt.offset != (bfd_vma) -1)
+       {
+         asection * splt;
+
+         splt = bfd_get_section_by_name (dynobj, ".plt");
+         
+         value = (splt->output_section->vma
+                  + splt->output_offset
+                  + h->plt.offset) - value;
+       }
+
+      value -= (input_section->output_section->vma
+               + input_section->output_offset);
+      value -= offset;
+      value += addend;
+
+      bfd_put_32 (input_bfd, value, hit_data);
+      return bfd_reloc_ok;
+
+    case R_MN10300_PLT16:
+      if (h != NULL
+         && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
+         && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
+         && h->plt.offset != (bfd_vma) -1)
+       {
+         asection * splt;
+
+         splt = bfd_get_section_by_name (dynobj, ".plt");
+         
+         value = (splt->output_section->vma
+                  + splt->output_offset
+                  + h->plt.offset) - value;
+       }
+
+      value -= (input_section->output_section->vma
+               + input_section->output_offset);
+      value -= offset;
+      value += addend;
+
+      if ((long) value > 0xffff || (long) value < -0x10000)
+       return bfd_reloc_overflow;
+
+      bfd_put_16 (input_bfd, value, hit_data);
+      return bfd_reloc_ok;
+
+    case R_MN10300_GOT32:
+    case R_MN10300_GOT24:
+    case R_MN10300_GOT16:
+      {
+       asection * sgot;
+
+       sgot = bfd_get_section_by_name (dynobj, ".got");
+       
+         if (h != NULL)
+           {
+             bfd_vma off;
+
+             off = h->got.offset;
+             BFD_ASSERT (off != (bfd_vma) -1);
+
+             if (! elf_hash_table (info)->dynamic_sections_created
+                 || (info->shared
+                     && (info->symbolic || h->dynindx == -1)
+                     && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
+               /* This is actually a static link, or it is a
+                  -Bsymbolic link and the symbol is defined
+                  locally, or the symbol was forced to be local
+                  because of a version file.  We must initialize
+                  this entry in the global offset table.
+
+                  When doing a dynamic link, we create a .rela.got
+                  relocation entry to initialize the value.  This
+                  is done in the finish_dynamic_symbol routine.  */
+               bfd_put_32 (output_bfd, value,
+                           sgot->contents + off);
+
+             value = sgot->output_offset + off;
+           }
+         else
+           {
+             bfd_vma off;
+
+             off = elf_local_got_offsets (input_bfd)[symndx];
+
+             bfd_put_32 (output_bfd, value, sgot->contents + off);
+
+             if (info->shared)
+               {
+                 asection * srelgot;
+                 Elf_Internal_Rela outrel;
+
+                 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+                 BFD_ASSERT (srelgot != NULL);
+
+                 outrel.r_offset = (sgot->output_section->vma
+                                    + sgot->output_offset
+                                    + off);
+                 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
+                 outrel.r_addend = value;
+                 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+                                            (((Elf32_External_Rela *)
+                                              srelgot->contents)
+                                             + srelgot->reloc_count));
+                 ++ srelgot->reloc_count;
+               }
+
+             value = sgot->output_offset + off;
+           }
+      }
+
+      value += addend;
+
+      if (r_type == R_MN10300_GOT32)
+       {
+         bfd_put_32 (input_bfd, value, hit_data);
+         return bfd_reloc_ok;
+       }
+      else if (r_type == R_MN10300_GOT24)
+       {
+         if ((long) value > 0x7fffff || (long) value < -0x800000)
+           return bfd_reloc_overflow;
+
+         bfd_put_8 (input_bfd, value & 0xff, hit_data);
+         bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
+         bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
+         return bfd_reloc_ok;
+       }
+      else if (r_type == R_MN10300_GOT16)
+       {
+         if ((long) value > 0xffff || (long) value < -0x10000)
+           return bfd_reloc_overflow;
+
+         bfd_put_16 (input_bfd, value, hit_data);
+         return bfd_reloc_ok;
+       }
+      /* Fall through.  */
+      
     default:
       return bfd_reloc_notsupported;
     }
@@ -598,17 +1587,66 @@ mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
              || h->root.root.type == bfd_link_hash_defweak)
            {
              sec = h->root.root.u.def.section;
-             relocation = (h->root.root.u.def.value
-                           + sec->output_section->vma
-                           + sec->output_offset);
+             if (   r_type == R_MN10300_GOTPC32
+                 || r_type == R_MN10300_GOTPC16
+                 || ((   r_type == R_MN10300_PLT32
+                      || r_type == R_MN10300_PLT16)
+                     && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
+                     && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
+                     && h->root.plt.offset != (bfd_vma) -1)
+                 || ((   r_type == R_MN10300_GOT32
+                      || r_type == R_MN10300_GOT24
+                      || r_type == R_MN10300_GOT16)
+                     && elf_hash_table (info)->dynamic_sections_created
+                     && (! info->shared
+                         || (! info->symbolic && h->root.dynindx != -1)
+                         || (h->root.elf_link_hash_flags
+                             & ELF_LINK_HASH_DEF_REGULAR) == 0))
+                 || (info->shared
+                     && ((! info->symbolic && h->root.dynindx != -1)
+                         || (h->root.elf_link_hash_flags
+                             & ELF_LINK_HASH_DEF_REGULAR) == 0)
+                     && (   r_type == R_MN10300_32
+                         || r_type == R_MN10300_PCREL32)
+                     && ((input_section->flags & SEC_ALLOC) != 0
+                         /* DWARF will emit R_MN10300_32 relocations
+                            in its sections against symbols defined
+                            externally in shared libraries.  We can't
+                            do anything with them here.  */
+                         || ((input_section->flags & SEC_DEBUGGING) != 0
+                             && (h->root.elf_link_hash_flags
+                                 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
+               {
+                 /* In these cases, we don't need the relocation
+                     value.  We check specially because in some
+                     obscure cases sec->output_section will be NULL.  */
+                 relocation = 0;
+               }
+             else if (sec->output_section == NULL)
+               {
+                 (*_bfd_error_handler)
+                   (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
+                    bfd_get_filename (input_bfd), h->root.root.root.string,
+                    bfd_get_section_name (input_bfd, input_section));
+                 relocation = 0;
+               }
+             else            
+               relocation = (h->root.root.u.def.value
+                             + sec->output_section->vma
+                             + sec->output_offset);
            }
          else if (h->root.root.type == bfd_link_hash_undefweak)
            relocation = 0;
+         else if (info->shared && !info->symbolic && !info->no_undefined
+                  && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
+           relocation = 0;
          else
            {
              if (! ((*info->callbacks->undefined_symbol)
                     (info, h->root.root.root.string, input_bfd,
-                     input_section, rel->r_offset, TRUE)))
+                     input_section, rel->r_offset,
+                     (!info->shared || info->no_undefined
+                      || ELF_ST_VISIBILITY (h->root.other)))))
                return FALSE;
              relocation = 0;
            }
@@ -618,6 +1656,8 @@ mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                                           input_section,
                                           contents, rel->r_offset,
                                           relocation, rel->r_addend,
+                                          (struct elf_link_hash_entry *)h,
+                                          r_symndx,
                                           info, sec, h == NULL);
 
       if (r != bfd_reloc_ok)
@@ -953,6 +1993,8 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
                         direct_calls counter.  Else force "call" to
                         "calls" conversions.  */
                      if (r_type == R_MN10300_PCREL32
+                         || r_type == R_MN10300_PLT32
+                         || r_type == R_MN10300_PLT16
                          || r_type == R_MN10300_PCREL16)
                        hash->direct_calls++;
                      else
@@ -1475,10 +2517,30 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
       /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
         branch/call, also deal with "call" -> "calls" conversions and
         insertion of prologue data into "call" instructions.  */
-      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32)
+      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
+         || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
        {
          bfd_vma value = symval;
 
+         if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
+             && h != NULL
+             && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
+             && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
+             && h->root.plt.offset != (bfd_vma) -1)
+           {
+             asection * splt;
+
+             splt = bfd_get_section_by_name (elf_hash_table (link_info)
+                                             ->dynobj, ".plt");
+         
+             value = ((splt->output_section->vma
+                       + splt->output_offset
+                       + h->root.plt.offset)
+                      - (sec->output_section->vma
+                         + sec->output_offset
+                         + irel->r_offset));
+           }
+
          /* If we've got a "call" instruction that needs to be turned
             into a "calls" instruction, do so now.  It saves a byte.  */
          if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
@@ -1567,6 +2629,9 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
 
              /* Fix the relocation's type.  */
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                          (ELF32_R_TYPE (irel->r_info)
+                                           == (int) R_MN10300_PLT32)
+                                          ? R_MN10300_PLT16 :
                                           R_MN10300_PCREL16);
 
              /* Delete two bytes of data.  */
@@ -1889,9 +2954,41 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
 
       /* Try to turn a 32bit immediate, displacement or absolute address
         into a 16bit immediate, displacement or absolute address.  */
-      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32)
+      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
+         || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
+         || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32
+         || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
        {
          bfd_vma value = symval;
+
+         if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
+           {
+             asection * sgot;
+
+             sgot = bfd_get_section_by_name (elf_hash_table (link_info)
+                                             ->dynobj, ".got");
+
+             if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
+               {
+                 value = sgot->output_offset;
+
+                 if (h)
+                   value += h->root.got.offset;
+                 else
+                   value += (elf_local_got_offsets
+                             (abfd)[ELF32_R_SYM (irel->r_info)]);
+               }
+             else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
+               value -= sgot->output_section->vma;
+             else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
+               value = (sgot->output_section->vma
+                        - (sec->output_section->vma
+                           + sec->output_offset
+                           + irel->r_offset));
+             else
+               abort ();
+           }
+
          value += irel->r_addend;
 
          /* See if the value will fit in 24 bits.
@@ -1917,6 +3014,8 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
                     equivalent instructions exists.  */
                  if (code != 0x6b && code != 0x7b
                      && code != 0x8b && code != 0x9b
+                     && (ELF32_R_TYPE (irel->r_info)
+                         != (int) R_MN10300_GOTPC32)
                      && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
                          || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
                          || (code & 0x0f) == 0x0e))
@@ -1940,6 +3039,12 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
                          /* Fix the relocation's type.  */
                          irel->r_info =
                            ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                         (ELF32_R_TYPE (irel->r_info)
+                                          == (int) R_MN10300_GOTOFF32)
+                                         ? R_MN10300_GOTOFF24
+                                         : (ELF32_R_TYPE (irel->r_info)
+                                            == (int) R_MN10300_GOT32)
+                                         ? R_MN10300_GOT24 :
                                          R_MN10300_24);
 
                          /* Delete one byte of data.  */
@@ -2018,6 +3123,15 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
 
                    /* Fix the relocation's type.  */
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                                (ELF32_R_TYPE (irel->r_info)
+                                                 == (int) R_MN10300_GOTOFF32)
+                                                ? R_MN10300_GOTOFF16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOT32)
+                                                ? R_MN10300_GOT16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOTPC32)
+                                                ? R_MN10300_GOTPC16 :
                                                 R_MN10300_16);
 
                    /* Delete two bytes of data.  */
@@ -2059,6 +3173,15 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
 
                    /* Fix the relocation's type.  */
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                                (ELF32_R_TYPE (irel->r_info)
+                                                 == (int) R_MN10300_GOTOFF32)
+                                                ? R_MN10300_GOTOFF16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOT32)
+                                                ? R_MN10300_GOT16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOTPC32)
+                                                ? R_MN10300_GOTPC16 :
                                                 R_MN10300_16);
 
                    /* The opcode got shorter too, so we have to fix the
@@ -2101,6 +3224,15 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
 
                    /* Fix the relocation's type.  */
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                                (ELF32_R_TYPE (irel->r_info)
+                                                 == (int) R_MN10300_GOTOFF32)
+                                                ? R_MN10300_GOTOFF16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOT32)
+                                                ? R_MN10300_GOT16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOTPC32)
+                                                ? R_MN10300_GOTPC16 :
                                                 R_MN10300_16);
 
                    /* Delete two bytes of data.  */
@@ -2161,6 +3293,15 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
 
                    /* Fix the relocation's type.  */
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                                (ELF32_R_TYPE (irel->r_info)
+                                                 == (int) R_MN10300_GOTOFF32)
+                                                ? R_MN10300_GOTOFF16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOT32)
+                                                ? R_MN10300_GOT16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOTPC32)
+                                                ? R_MN10300_GOTPC16 :
                                                 R_MN10300_16);
 
                    /* The opcode got shorter too, so we have to fix the
@@ -2226,6 +3367,15 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
 
                    /* Fix the relocation's type.  */
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                                (ELF32_R_TYPE (irel->r_info)
+                                                 == (int) R_MN10300_GOTOFF32)
+                                                ? R_MN10300_GOTOFF16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOT32)
+                                                ? R_MN10300_GOT16
+                                                : (ELF32_R_TYPE (irel->r_info)
+                                                   == (int) R_MN10300_GOTPC32)
+                                                ? R_MN10300_GOTPC16 :
                                                 R_MN10300_16);
 
                    /* Delete two bytes of data.  */
@@ -2253,6 +3403,15 @@ mn10300_elf_relax_section (abfd, sec, link_info, again)
 
                  /* Fix the relocation's type.  */
                  irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
+                                              (ELF32_R_TYPE (irel->r_info)
+                                               == (int) R_MN10300_GOT32)
+                                              ? R_MN10300_GOT16
+                                              : (ELF32_R_TYPE (irel->r_info)
+                                                 == (int) R_MN10300_GOTOFF32)
+                                              ? R_MN10300_GOTOFF16
+                                              : (ELF32_R_TYPE (irel->r_info)
+                                                 == (int) R_MN10300_GOTPC32)
+                                              ? R_MN10300_GOTPC16 :
                                               R_MN10300_16);
 
                  /* Delete two bytes of data.  */
@@ -2678,6 +3837,7 @@ elf32_mn10300_link_hash_newfunc (entry, table, string)
       ret->stack_size = 0;
       ret->movm_args = 0;
       ret->movm_stack_size = 0;
+      ret->pcrel_relocs_copied = NULL;
       ret->flags = 0;
     }
 
@@ -2820,6 +3980,868 @@ _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
   return TRUE;
 }
 
+#define PLT0_ENTRY_SIZE 15
+#define PLT_ENTRY_SIZE 20
+#define PIC_PLT_ENTRY_SIZE 24
+
+static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
+{
+  0xfc, 0xa0, 0, 0, 0, 0,      /* mov  (.got+8),a0 */
+  0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov  (.got+4),r1 */
+  0xf0, 0xf4,                  /* jmp  (a0) */
+};
+
+static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
+{
+  0xfc, 0xa0, 0, 0, 0, 0,      /* mov  (nameN@GOT + .got),a0 */
+  0xf0, 0xf4,                  /* jmp  (a0) */
+  0xfe, 8, 0, 0, 0, 0, 0,      /* mov  reloc-table-address,r0 */
+  0xdc, 0, 0, 0, 0,            /* jmp  .plt0 */
+};
+
+static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
+{
+  0xfc, 0x22, 0, 0, 0, 0,      /* mov  (nameN@GOT,a2),a0 */
+  0xf0, 0xf4,                  /* jmp  (a0) */
+  0xfe, 8, 0, 0, 0, 0, 0,      /* mov  reloc-table-address,r0 */
+  0xf8, 0x22, 8,               /* mov  (8,a2),a0 */
+  0xfb, 0xa, 0x1a, 4,          /* mov  (4,a2),r1 */
+  0xf0, 0xf4,                  /* jmp  (a0) */
+};
+
+/* Return size of the first PLT entry.  */
+#define elf_mn10300_sizeof_plt0(info) \
+  (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
+
+/* Return size of a PLT entry.  */
+#define elf_mn10300_sizeof_plt(info) \
+  (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
+
+/* Return offset of the PLT0 address in an absolute PLT entry.  */
+#define elf_mn10300_plt_plt0_offset(info) 16
+
+/* Return offset of the linker in PLT0 entry.  */
+#define elf_mn10300_plt0_linker_offset(info) 2
+
+/* Return offset of the GOT id in PLT0 entry.  */
+#define elf_mn10300_plt0_gotid_offset(info) 9
+
+/* Return offset of the tempoline in PLT entry */
+#define elf_mn10300_plt_temp_offset(info) 8
+
+/* Return offset of the symbol in PLT entry.  */
+#define elf_mn10300_plt_symbol_offset(info) 2
+
+/* Return offset of the relocation in PLT entry.  */
+#define elf_mn10300_plt_reloc_offset(info) 11
+
+/* The name of the dynamic interpreter.  This is put in the .interp
+   section.  */
+
+#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
+
+/* Create dynamic sections when linking against a dynamic object.  */
+
+static bfd_boolean
+_bfd_mn10300_elf_create_dynamic_sections (abfd, info)
+     bfd *abfd;
+     struct bfd_link_info *info;
+{
+  flagword   flags;
+  asection * s;
+  struct elf_backend_data * bed = get_elf_backend_data (abfd);
+  int ptralign = 0;
+
+  switch (bed->s->arch_size)
+    {
+    case 32:
+      ptralign = 2;
+      break;
+
+    case 64:
+      ptralign = 3;
+      break;
+
+    default:
+      bfd_set_error (bfd_error_bad_value);
+      return FALSE;
+    }
+
+  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
+     .rel[a].bss sections.  */
+
+  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
+          | SEC_LINKER_CREATED);
+
+  s = bfd_make_section (abfd,
+                       bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
+  if (s == NULL
+      || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
+      || ! bfd_set_section_alignment (abfd, s, ptralign))
+    return FALSE;
+
+  if (! _bfd_mn10300_elf_create_got_section (abfd, info))
+    return FALSE;
+
+  {
+    const char * secname;
+    char *       relname;
+    flagword     secflags;
+    asection *   sec;
+
+    for (sec = abfd->sections; sec; sec = sec->next)
+      {
+       secflags = bfd_get_section_flags (abfd, sec);
+       if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
+           || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
+         continue;
+
+       secname = bfd_get_section_name (abfd, sec);
+       relname = (char *) bfd_malloc (strlen (secname) + 6);
+       strcpy (relname, ".rela");
+       strcat (relname, secname);
+
+       s = bfd_make_section (abfd, relname);
+       if (s == NULL
+           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
+           || ! bfd_set_section_alignment (abfd, s, ptralign))
+         return FALSE;
+      }
+  }
+
+  if (bed->want_dynbss)
+    {
+      /* The .dynbss section is a place to put symbols which are defined
+        by dynamic objects, are referenced by regular objects, and are
+        not functions.  We must allocate space for them in the process
+        image and use a R_*_COPY reloc to tell the dynamic linker to
+        initialize them at run time.  The linker script puts the .dynbss
+        section into the .bss section of the final image.  */
+      s = bfd_make_section (abfd, ".dynbss");
+      if (s == NULL
+         || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
+       return FALSE;
+
+      /* The .rel[a].bss section holds copy relocs.  This section is not
+        normally needed.  We need to create it here, though, so that the
+        linker will map it to an output section.  We can't just create it
+        only if we need it, because we will not know whether we need it
+        until we have seen all the input files, and the first time the
+        main linker code calls BFD after examining all the input files
+        (size_dynamic_sections) the input sections have already been
+        mapped to the output sections.  If the section turns out not to
+        be needed, we can discard it later.  We will never need this
+        section when generating a shared object, since they do not use
+        copy relocs.  */
+      if (! info->shared)
+       {
+         s = bfd_make_section (abfd,
+                               (bed->default_use_rela_p
+                                ? ".rela.bss" : ".rel.bss"));
+         if (s == NULL
+             || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
+             || ! bfd_set_section_alignment (abfd, s, ptralign))
+           return FALSE;
+       }
+    }
+
+  return TRUE;
+}
+\f
+/* 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
+   change the definition to something the rest of the link can
+   understand.  */
+
+static bfd_boolean
+_bfd_mn10300_elf_adjust_dynamic_symbol (info, h)
+     struct bfd_link_info * info;
+     struct elf_link_hash_entry * h;
+{
+  bfd * dynobj;
+  asection * s;
+  unsigned int power_of_two;
+
+  dynobj = elf_hash_table (info)->dynobj;
+
+  /* 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 PLT 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 REL32
+            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 += elf_mn10300_sizeof_plt0 (info);
+
+      /* 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 = s->_raw_size;
+       }
+
+      h->plt.offset = s->_raw_size;
+
+      /* Make room for this entry.  */
+      s->_raw_size += elf_mn10300_sizeof_plt (info);
+
+      /* We also need to make an entry in the .got.plt section, which
+        will be placed in the .got section by the linker script.  */
+
+      s = bfd_get_section_by_name (dynobj, ".got.plt");
+      BFD_ASSERT (s != NULL);
+      s->_raw_size += 4;
+
+      /* 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;
+
+  /* If there are no references to this symbol that do not use the
+     GOT, we don't need to generate a copy reloc.  */
+  if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
+    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);
+
+  /* We must generate a R_MN10300_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_ALLOC) != 0)
+    {
+      asection * srel;
+
+      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
+      BFD_ASSERT (srel != NULL);
+      srel->_raw_size += sizeof (Elf32_External_Rela);
+      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;
+}
+
+/* This function is called via elf32_mn10300_link_hash_traverse if we are
+   creating a shared object with -Bsymbolic.  It discards the space
+   allocated to copy PC relative relocs against symbols which are
+   defined in regular objects.  We allocated space for them in the
+   check_relocs routine, but we won't fill them in in the
+   relocate_section routine.  */
+
+static bfd_boolean
+_bfd_mn10300_elf_discard_copies (h, info)
+     struct elf32_mn10300_link_hash_entry *h;
+     struct bfd_link_info *info;
+{
+  struct elf_mn10300_pcrel_relocs_copied *s;
+
+  /* If a symbol has been forced local or we have found a regular
+     definition for the symbolic link case, then we won't be needing
+     any relocs.  */
+  if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
+      && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
+         || info->symbolic))
+    {
+      for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
+       s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
+    }
+
+  return TRUE;
+}
+
+/* Set the sizes of the dynamic sections.  */
+
+static bfd_boolean
+_bfd_mn10300_elf_size_dynamic_sections (output_bfd, info)
+     bfd * output_bfd;
+     struct bfd_link_info * info;
+{
+  bfd * dynobj;
+  asection * s;
+  bfd_boolean plt;
+  bfd_boolean relocs;
+  bfd_boolean reltext;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  BFD_ASSERT (dynobj != NULL);
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      /* Set the contents of the .interp section to the interpreter.  */
+      if (! info->shared)
+       {
+         s = bfd_get_section_by_name (dynobj, ".interp");
+         BFD_ASSERT (s != NULL);
+         s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
+         s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
+       }
+    }
+  else
+    {
+      /* We may have created entries in the .rela.got section.
+        However, if we are not creating the dynamic sections, we will
+        not actually use these entries.  Reset the size of .rela.got,
+        which will cause it to get stripped from the output file
+        below.  */
+      s = bfd_get_section_by_name (dynobj, ".rela.got");
+      if (s != NULL)
+       s->_raw_size = 0;
+    }
+
+  /* If this is a -Bsymbolic shared link, then we need to discard all
+     PC relative relocs against symbols defined in a regular object.
+     We allocated space for them in the check_relocs routine, but we
+     will not fill them in in the relocate_section routine.  */
+  if (info->shared && info->symbolic)
+    elf32_mn10300_link_hash_traverse (elf32_mn10300_hash_table (info),
+                                     _bfd_mn10300_elf_discard_copies,
+                                     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;
+  for (s = dynobj->sections; s != NULL; s = s->next)
+    {
+      const char * name;
+      bfd_boolean strip;
+
+      if ((s->flags & SEC_LINKER_CREATED) == 0)
+       continue;
+
+      /* It's OK to base decisions on the section name, because none
+        of the dynobj section names depend upon the input files.  */
+      name = bfd_get_section_name (dynobj, s);
+
+      strip = FALSE;
+
+      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 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
+                function which decides whether anything needs to go
+                into these sections.  */
+             strip = TRUE;
+           }
+         else
+           {
+             asection * target;
+
+             /* Remember whether there are any reloc sections other
+                than .rela.plt.  */
+             if (strcmp (name, ".rela.plt") != 0)
+               {
+                 const char * outname;
+
+                 relocs = TRUE;
+
+                 /* If this relocation section applies to a read only
+                    section, then we probably need a DT_TEXTREL
+                    entry.  The entries in the .rela.plt section
+                    really apply to the .got section, which we
+                    created ourselves and so know is not readonly.  */
+                 outname = bfd_get_section_name (output_bfd,
+                                                 s->output_section);
+                 target = bfd_get_section_by_name (output_bfd, outname + 5);
+                 if (target != NULL
+                     && (target->flags & SEC_READONLY) != 0
+                     && (target->flags & SEC_ALLOC) != 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 if (strncmp (name, ".got", 4) != 0)
+       /* It's not one of our sections, so don't allocate space.  */
+       continue;
+
+      if (strip)
+       {
+         _bfd_strip_section_from_output (info, s);
+         continue;
+       }
+
+      /* Allocate memory for the section contents.  We use bfd_zalloc
+        here in case unused entries are not reclaimed before the
+        section's contents are written out.  This should not happen,
+        but this way if it does, we get a R_MN10300_NONE reloc
+        instead of garbage.  */
+      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
+      if (s->contents == NULL && s->_raw_size != 0)
+       return FALSE;
+    }
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      /* Add some entries to the .dynamic section.  We fill in the
+        values later, in _bfd_mn10300_elf_finish_dynamic_sections,
+        but we must add the entries now so that we get the correct
+        size for the .dynamic section.  The DT_DEBUG entry is filled
+        in by the dynamic linker and used by the debugger.  */
+      if (! info->shared)
+       {
+         if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
+           return FALSE;
+       }
+
+      if (plt)
+       {
+         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_RELA)
+             || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
+           return FALSE;
+       }
+
+      if (relocs)
+       {
+         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 (reltext)
+       {
+         if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
+           return FALSE;
+       }
+    }
+
+  return TRUE;
+}
+
+/* Finish up dynamic symbol handling.  We set the contents of various
+   dynamic sections here.  */
+
+static bfd_boolean
+_bfd_mn10300_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
+     bfd * output_bfd;
+     struct bfd_link_info * info;
+     struct elf_link_hash_entry * h;
+     Elf_Internal_Sym * sym;
+{
+  bfd * dynobj;
+
+  dynobj = elf_hash_table (info)->dynobj;
+
+  if (h->plt.offset != (bfd_vma) -1)
+    {
+      asection *        splt;
+      asection *        sgot;
+      asection *        srel;
+      bfd_vma           plt_index;
+      bfd_vma           got_offset;
+      Elf_Internal_Rela rel;
+
+      /* This symbol has an entry in the procedure linkage table.  Set
+        it up.  */
+
+      BFD_ASSERT (h->dynindx != -1);
+
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
+      srel = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
+
+      /* Get the index in the procedure linkage table which
+        corresponds to this symbol.  This is the index of this symbol
+        in all the symbols for which we are making plt entries.  The
+        first entry in the procedure linkage table is reserved.  */
+      plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
+                  / elf_mn10300_sizeof_plt (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;
+
+      /* Fill in the entry in the procedure linkage table.  */
+      if (! info->shared)
+       {
+         memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
+                 elf_mn10300_sizeof_plt (info));
+         bfd_put_32 (output_bfd,
+                     (sgot->output_section->vma
+                      + sgot->output_offset
+                      + got_offset),
+                     (splt->contents + h->plt.offset
+                      + elf_mn10300_plt_symbol_offset (info)));
+
+         bfd_put_32 (output_bfd,
+                     (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
+                     (splt->contents + h->plt.offset
+                      + elf_mn10300_plt_plt0_offset (info)));
+       }
+      else
+       {
+         memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
+                 elf_mn10300_sizeof_plt (info));
+
+         bfd_put_32 (output_bfd, got_offset,
+                     (splt->contents + h->plt.offset
+                      + elf_mn10300_plt_symbol_offset (info)));
+       }
+
+      bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
+                 (splt->contents + h->plt.offset
+                  + elf_mn10300_plt_reloc_offset (info)));
+
+      /* Fill in the entry in the global offset table.  */
+      bfd_put_32 (output_bfd,
+                 (splt->output_section->vma
+                  + splt->output_offset
+                  + h->plt.offset
+                  + elf_mn10300_plt_temp_offset (info)),
+                 sgot->contents + got_offset);
+
+      /* Fill in the entry in the .rela.plt section.  */
+      rel.r_offset = (sgot->output_section->vma
+                     + sgot->output_offset
+                     + got_offset);
+      rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
+      rel.r_addend = 0;
+      bfd_elf32_swap_reloca_out (output_bfd, &rel,
+                               ((Elf32_External_Rela *) srel->contents
+                                + plt_index));
+
+      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+       /* Mark the symbol as undefined, rather than as defined in
+          the .plt section.  Leave the value alone.  */
+       sym->st_shndx = SHN_UNDEF;
+    }
+
+  if (h->got.offset != (bfd_vma) -1)
+    {
+      asection *        sgot;
+      asection *        srel;
+      Elf_Internal_Rela rel;
+
+      /* This symbol has an entry in the global offset table.  Set it up.  */
+
+      sgot = bfd_get_section_by_name (dynobj, ".got");
+      srel = bfd_get_section_by_name (dynobj, ".rela.got");
+      BFD_ASSERT (sgot != NULL && srel != NULL);
+
+      rel.r_offset = (sgot->output_section->vma
+                     + sgot->output_offset
+                     + (h->got.offset &~ 1));
+
+      /* If this is a -Bsymbolic link, and the symbol is defined
+        locally, we just want to emit a RELATIVE reloc.  Likewise if
+        the symbol was forced to be local because of a version file.
+        The entry in the global offset table will already have been
+        initialized in the relocate_section function.  */
+      if (info->shared
+         && (info->symbolic || h->dynindx == -1)
+         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
+       {
+         rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
+         rel.r_addend = (h->root.u.def.value
+                         + h->root.u.def.section->output_section->vma
+                         + h->root.u.def.section->output_offset);
+       }
+      else
+       {
+         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
+         rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
+         rel.r_addend = 0;
+       }
+
+      bfd_elf32_swap_reloca_out (output_bfd, &rel,
+                                ((Elf32_External_Rela *) srel->contents
+                                 + srel->reloc_count));
+      ++ srel->reloc_count;
+    }
+
+  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
+    {
+      asection *        s;
+      Elf_Internal_Rela rel;
+
+      /* This symbol needs a copy reloc.  Set it up.  */
+      BFD_ASSERT (h->dynindx != -1
+                 && (h->root.type == bfd_link_hash_defined
+                     || h->root.type == bfd_link_hash_defweak));
+
+      s = bfd_get_section_by_name (h->root.u.def.section->owner,
+                                  ".rela.bss");
+      BFD_ASSERT (s != NULL);
+
+      rel.r_offset = (h->root.u.def.value
+                     + h->root.u.def.section->output_section->vma
+                     + h->root.u.def.section->output_offset);
+      rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
+      rel.r_addend = 0;
+      bfd_elf32_swap_reloca_out (output_bfd, &rel,
+                                ((Elf32_External_Rela *) s->contents
+                                 + s->reloc_count));
+      ++ s->reloc_count;
+    }
+
+  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
+  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+      || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
+    sym->st_shndx = SHN_ABS;
+
+  return TRUE;
+}
+
+/* Finish up the dynamic sections.  */
+
+static bfd_boolean
+_bfd_mn10300_elf_finish_dynamic_sections (output_bfd, info)
+     bfd * output_bfd;
+     struct bfd_link_info * info;
+{
+  bfd *      dynobj;
+  asection * sgot;
+  asection * sdyn;
+
+  dynobj = elf_hash_table (info)->dynobj;
+
+  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
+  BFD_ASSERT (sgot != NULL);
+  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+
+  if (elf_hash_table (info)->dynamic_sections_created)
+    {
+      asection *           splt;
+      Elf32_External_Dyn * dyncon;
+      Elf32_External_Dyn * dynconend;
+
+      BFD_ASSERT (sdyn != NULL);
+
+      dyncon = (Elf32_External_Dyn *) sdyn->contents;
+      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
+
+      for (; dyncon < dynconend; dyncon++)
+       {
+         Elf_Internal_Dyn dyn;
+         const char * name;
+         asection * s;
+
+         bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
+
+         switch (dyn.d_tag)
+           {
+           default:
+             break;
+
+           case DT_PLTGOT:
+             name = ".got";
+             goto get_vma;
+
+           case DT_JMPREL:
+             name = ".rela.plt";
+           get_vma:
+             s = bfd_get_section_by_name (output_bfd, name);
+             BFD_ASSERT (s != NULL);
+             dyn.d_un.d_ptr = s->vma;
+             bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+             break;
+
+           case DT_PLTRELSZ:
+             s = bfd_get_section_by_name (output_bfd, ".rela.plt");
+             BFD_ASSERT (s != NULL);
+             if (s->_cooked_size != 0)
+               dyn.d_un.d_val = s->_cooked_size;
+             else
+               dyn.d_un.d_val = s->_raw_size;
+             bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+             break;
+
+           case DT_RELASZ:
+             /* My reading of the SVR4 ABI indicates that the
+                procedure linkage table relocs (DT_JMPREL) should be
+                included in the overall relocs (DT_RELA).  This is
+                what Solaris does.  However, UnixWare can not handle
+                that case.  Therefore, we override the DT_RELASZ entry
+                here to make it not include the JMPREL relocs.  Since
+                the linker script arranges for .rela.plt to follow all
+                other relocation sections, we don't have to worry
+                about changing the DT_RELA entry.  */
+             s = bfd_get_section_by_name (output_bfd, ".rela.plt");
+             if (s != NULL)
+               {
+                 if (s->_cooked_size != 0)
+                   dyn.d_un.d_val -= s->_cooked_size;
+                 else
+                   dyn.d_un.d_val -= s->_raw_size;
+               }
+             bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+             break;
+           }
+       }
+
+      /* Fill in the first entry in the procedure linkage table.  */
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      if (splt && splt->_raw_size > 0)
+       {
+         if (info->shared)
+           {
+             memcpy (splt->contents, elf_mn10300_pic_plt_entry,
+                     elf_mn10300_sizeof_plt (info));
+           }
+         else
+           {
+             memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
+             bfd_put_32 (output_bfd,
+                         sgot->output_section->vma + sgot->output_offset + 4,
+                         splt->contents + elf_mn10300_plt0_gotid_offset (info));
+             bfd_put_32 (output_bfd,
+                         sgot->output_section->vma + sgot->output_offset + 8,
+                         splt->contents + elf_mn10300_plt0_linker_offset (info));
+           }
+
+         /* UnixWare sets the entsize of .plt to 4, although that doesn't
+            really seem like the right value.  */
+         elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
+       }
+    }
+
+  /* Fill in the first three entries in the global offset table.  */
+  if (sgot->_raw_size > 0)
+    {
+      if (sdyn == NULL)
+       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
+      else
+       bfd_put_32 (output_bfd,
+                   sdyn->output_section->vma + sdyn->output_offset,
+                   sgot->contents);
+      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
+      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
+    }
+
+  elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
+
+  return TRUE;
+}
+
 #define TARGET_LITTLE_SYM      bfd_elf32_mn10300_vec
 #define TARGET_LITTLE_NAME     "elf32-mn10300"
 #define ELF_ARCH               bfd_arch_mn10300
@@ -2852,4 +4874,22 @@ _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
 #define bfd_elf32_bfd_merge_private_bfd_data \
                                         _bfd_mn10300_elf_merge_private_bfd_data
 
+#define elf_backend_can_gc_sections    1
+#define elf_backend_create_dynamic_sections \
+  _bfd_mn10300_elf_create_dynamic_sections
+#define elf_backend_adjust_dynamic_symbol \
+  _bfd_mn10300_elf_adjust_dynamic_symbol
+#define elf_backend_size_dynamic_sections \
+  _bfd_mn10300_elf_size_dynamic_sections
+#define elf_backend_finish_dynamic_symbol \
+  _bfd_mn10300_elf_finish_dynamic_symbol
+#define elf_backend_finish_dynamic_sections \
+  _bfd_mn10300_elf_finish_dynamic_sections
+
+#define elf_backend_want_got_plt       1
+#define elf_backend_plt_readonly       1
+#define elf_backend_want_plt_sym       0
+#define elf_backend_got_header_size    12
+#define elf_backend_plt_header_size    PLT0_ENTRY_SIZE
+
 #include "elf32-target.h"
index a794d50..61c8e65 100644 (file)
@@ -863,6 +863,14 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@",
   "BFD_RELOC_FRV_GPREL32",
   "BFD_RELOC_FRV_GPRELHI",
   "BFD_RELOC_FRV_GPRELLO",
+  "BFD_RELOC_MN10300_GOTOFF24",
+  "BFD_RELOC_MN10300_GOT32",
+  "BFD_RELOC_MN10300_GOT24",
+  "BFD_RELOC_MN10300_GOT16",
+  "BFD_RELOC_MN10300_COPY",
+  "BFD_RELOC_MN10300_GLOB_DAT",
+  "BFD_RELOC_MN10300_JMP_SLOT",
+  "BFD_RELOC_MN10300_RELATIVE",
 
   "BFD_RELOC_386_GOT32",
   "BFD_RELOC_386_PLT32",
index e50eb11..58c9c51 100644 (file)
@@ -2143,6 +2143,42 @@ ENUMDOC
   MIPS ELF relocations.
 
 COMMENT
+ENUM
+  BFD_RELOC_MN10300_GOTOFF24
+ENUMDOC
+  This is a 24bit GOT-relative reloc for the mn10300.
+ENUM
+  BFD_RELOC_MN10300_GOT32
+ENUMDOC
+  This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes
+  in the instruction.
+ENUM
+  BFD_RELOC_MN10300_GOT24
+ENUMDOC
+  This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes
+  in the instruction.
+ENUM
+  BFD_RELOC_MN10300_GOT16
+ENUMDOC
+  This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes
+  in the instruction.
+ENUM
+  BFD_RELOC_MN10300_COPY
+ENUMDOC
+  Copy symbol at runtime.
+ENUM
+  BFD_RELOC_MN10300_GLOB_DAT
+ENUMDOC
+  Create GOT entry.
+ENUM
+  BFD_RELOC_MN10300_JMP_SLOT
+ENUMDOC
+  Create PLT entry.
+ENUM
+  BFD_RELOC_MN10300_RELATIVE
+ENUMDOC
+  Adjust by program base.
+COMMENT
 
 ENUM
   BFD_RELOC_386_GOT32