ubsan: xgate: left shift of negative value

[deliverable/binutils-gdb.git] / bfd / elf32-m32c.c
diff --git a/bfd/elf32-m32c.c b/bfd/elf32-m32c.c

index 3f9bb4e06cec1c055dd577e9f78874dbb1e6d3da..70ccd6203abdc6acabc70a6fa5bc875031bcfd0f 100644 (file)
--- a/bfd/elf32-m32c.c
+++ b/bfd/elf32-m32c.c
@@ -1,12 +1,11 @@
  /* M16C/M32C specific support for 32-bit ELF.
  /* M16C/M32C specific support for 32-bit ELF.
-   Copyright (C) 2005
-   Free Software Foundation, Inc.
+   Copyright (C) 2005-2020 Free Software Foundation, Inc.
  
     This file is part of BFD, the Binary File Descriptor library.
  
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
  
     This file is part of BFD, the Binary File Descriptor library.
  
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
     (at your option) any later version.
  
     This program is distributed in the hope that it will be useful,
     (at your option) any later version.
  
     This program is distributed in the hope that it will be useful,
@@ -16,10 +15,11 @@
  
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
  
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
  
  
-#include "bfd.h"
  #include "sysdep.h"
  #include "sysdep.h"
+#include "bfd.h"
  #include "libbfd.h"
  #include "elf-bfd.h"
  #include "elf/m32c.h"
  #include "libbfd.h"
  #include "elf-bfd.h"
  #include "elf/m32c.h"
@@ -28,22 +28,21 @@
  /* Forward declarations.  */
  static reloc_howto_type * m32c_reloc_type_lookup
    (bfd *, bfd_reloc_code_real_type);
  /* Forward declarations.  */
  static reloc_howto_type * m32c_reloc_type_lookup
    (bfd *, bfd_reloc_code_real_type);
-static void m32c_info_to_howto_rela 
+static bfd_boolean m32c_info_to_howto_rela
    (bfd *, arelent *, Elf_Internal_Rela *);
    (bfd *, arelent *, Elf_Internal_Rela *);
-static bfd_boolean m32c_elf_relocate_section 
+static bfd_boolean m32c_elf_relocate_section
    (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
    (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
-static bfd_boolean m32c_elf_gc_sweep_hook
-  (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
-static asection * m32c_elf_gc_mark_hook
-  (asection *, struct bfd_link_info *, Elf_Internal_Rela *, struct elf_link_hash_entry *, Elf_Internal_Sym *);
  static bfd_boolean m32c_elf_check_relocs
    (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
  static bfd_boolean m32c_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int);
  #ifdef DEBUG
  static bfd_boolean m32c_elf_check_relocs
    (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
  static bfd_boolean m32c_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int);
  #ifdef DEBUG
-static char * m32c_get_reloc (long reloc);
+char * m32c_get_reloc (long reloc);
+void dump_symtab (bfd *, void *, void *);
  #endif
  static bfd_boolean m32c_elf_relax_section
  (bfd *abfd, asection *sec, struct bfd_link_info *link_info, bfd_boolean *again);
  #endif
  static bfd_boolean m32c_elf_relax_section
  (bfd *abfd, asection *sec, struct bfd_link_info *link_info, bfd_boolean *again);
+static bfd_reloc_status_type m32c_apply_reloc_24
+  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  
  
  static reloc_howto_type m32c_elf_howto_table [] =
  
  
  static reloc_howto_type m32c_elf_howto_table [] =
@@ -51,11 +50,11 @@ static reloc_howto_type m32c_elf_howto_table [] =
    /* This reloc does nothing.  */
    HOWTO (R_M32C_NONE,          /* type */
          0,                     /* rightshift */
    /* This reloc does nothing.  */
    HOWTO (R_M32C_NONE,          /* type */
          0,                     /* rightshift */
-        0,                     /* size (0 = byte, 1 = short, 2 = long) */
-        32,                    /* bitsize */
+        3,                     /* size (0 = byte, 1 = short, 2 = long) */
+        0,                     /* bitsize */
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
-        complain_overflow_bitfield, /* complain_on_overflow */
+        complain_overflow_dont, /* complain_on_overflow */
          bfd_elf_generic_reloc, /* special_function */
          "R_M32C_NONE",         /* name */
          FALSE,                 /* partial_inplace */
          bfd_elf_generic_reloc, /* special_function */
          "R_M32C_NONE",         /* name */
          FALSE,                 /* partial_inplace */
@@ -63,18 +62,21 @@ static reloc_howto_type m32c_elf_howto_table [] =
          0,                     /* dst_mask */
          FALSE),                /* pcrel_offset */
  
          0,                     /* dst_mask */
          FALSE),                /* pcrel_offset */
  
+  /* GCC intentionally overflows these next two in order to work
+     around limitations in the addressing modes, so don't complain
+     about overflow.  */
    HOWTO (R_M32C_16,            /* type */
          0,                     /* rightshift */
          1,                     /* size (0 = byte, 1 = short, 2 = long) */
          16,                    /* bitsize */
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
    HOWTO (R_M32C_16,            /* type */
          0,                     /* rightshift */
          1,                     /* size (0 = byte, 1 = short, 2 = long) */
          16,                    /* bitsize */
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
-        complain_overflow_bitfield, /* complain_on_overflow */
+        complain_overflow_dont, /* complain_on_overflow */
          bfd_elf_generic_reloc, /* special_function */
          "R_M32C_16",           /* name */
          FALSE,                 /* partial_inplace */
          0,                     /* src_mask */
          bfd_elf_generic_reloc, /* special_function */
          "R_M32C_16",           /* name */
          FALSE,                 /* partial_inplace */
          0,                     /* src_mask */
-        0x0000ffff,            /* dst_mask */
+        0xffff,                /* dst_mask */
          FALSE),                /* pcrel_offset */
  
    HOWTO (R_M32C_24,            /* type */
          FALSE),                /* pcrel_offset */
  
    HOWTO (R_M32C_24,            /* type */
@@ -83,12 +85,12 @@ static reloc_howto_type m32c_elf_howto_table [] =
          24,                    /* bitsize */
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          24,                    /* bitsize */
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
-        complain_overflow_bitfield, /* complain_on_overflow */
-        bfd_elf_generic_reloc, /* special_function */
+        complain_overflow_dont, /* complain_on_overflow */
+        m32c_apply_reloc_24,   /* special_function */
          "R_M32C_24",           /* name */
          FALSE,                 /* partial_inplace */
          0,                     /* src_mask */
          "R_M32C_24",           /* name */
          FALSE,                 /* partial_inplace */
          0,                     /* src_mask */
-        0x00ffffff,            /* dst_mask */
+        0xffffff,              /* dst_mask */
          FALSE),                /* pcrel_offset */
  
    HOWTO (R_M32C_32,            /* type */
          FALSE),                /* pcrel_offset */
  
    HOWTO (R_M32C_32,            /* type */
@@ -115,9 +117,9 @@ static reloc_howto_type m32c_elf_howto_table [] =
          bfd_elf_generic_reloc, /* special_function */
          "R_M32C_8_PCREL",      /* name */
          FALSE,                 /* partial_inplace */
          bfd_elf_generic_reloc, /* special_function */
          "R_M32C_8_PCREL",      /* name */
          FALSE,                 /* partial_inplace */
-        0,                     /* src_mask */
-        0x000000ff,            /* dst_mask */
-        TRUE),                 /* pcrel_offset */
+        0,                     /* src_mask */
+        0xff,                  /* dst_mask */
+        TRUE),                 /* pcrel_offset */
  
    HOWTO (R_M32C_16_PCREL,      /* type */
          0,                     /* rightshift */
  
    HOWTO (R_M32C_16_PCREL,      /* type */
          0,                     /* rightshift */
@@ -129,9 +131,108 @@ static reloc_howto_type m32c_elf_howto_table [] =
          bfd_elf_generic_reloc, /* special_function */
          "R_M32C_16_PCREL",     /* name */
          FALSE,                 /* partial_inplace */
          bfd_elf_generic_reloc, /* special_function */
          "R_M32C_16_PCREL",     /* name */
          FALSE,                 /* partial_inplace */
-        0,                     /* src_mask */
-        0,                     /* dst_mask */
-        TRUE),                 /* pcrel_offset */
+        0,                     /* src_mask */
+        0xffff,                /* dst_mask */
+        TRUE),                 /* pcrel_offset */
+
+  HOWTO (R_M32C_8,             /* type */
+        0,                     /* rightshift */
+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
+        8,                     /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_unsigned, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* special_function */
+        "R_M32C_8",            /* name */
+        FALSE,                 /* partial_inplace */
+        0,                     /* src_mask */
+        0xff,                  /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_M32C_LO16,          /* type */
+        0,                     /* rightshift */
+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
+        16,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_dont, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* special_function */
+        "R_M32C_LO16",         /* name */
+        FALSE,                 /* partial_inplace */
+        0,                     /* src_mask */
+        0xffff,                /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_M32C_HI8,           /* type */
+        0,                     /* rightshift */
+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
+        8,                     /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_dont, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* special_function */
+        "R_M32C_HI8",          /* name */
+        FALSE,                 /* partial_inplace */
+        0,                     /* src_mask */
+        0xff,                  /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_M32C_HI16,          /* type */
+        0,                     /* rightshift */
+        1,                     /* size (0 = byte, 1 = short, 2 = long) */
+        16,                    /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_dont, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* special_function */
+        "R_M32C_HI16",         /* name */
+        FALSE,                 /* partial_inplace */
+        0,                     /* src_mask */
+        0xffff,                /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_M32C_RL_JUMP,       /* type */
+        0,                     /* rightshift */
+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
+        0,                     /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_signed, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* special_function */
+        "R_M32C_RL_JUMP",      /* name */
+        FALSE,                 /* partial_inplace */
+        0,                     /* src_mask */
+        0,                     /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_M32C_RL_1ADDR,      /* type */
+        0,                     /* rightshift */
+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
+        0,                     /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_signed, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* special_function */
+        "R_M32C_RL_1ADDR",     /* name */
+        FALSE,                 /* partial_inplace */
+        0,                     /* src_mask */
+        0,                     /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
+  HOWTO (R_M32C_RL_2ADDR,      /* type */
+        0,                     /* rightshift */
+        0,                     /* size (0 = byte, 1 = short, 2 = long) */
+        0,                     /* bitsize */
+        FALSE,                 /* pc_relative */
+        0,                     /* bitpos */
+        complain_overflow_signed, /* complain_on_overflow */
+        bfd_elf_generic_reloc, /* special_function */
+        "R_M32C_RL_2ADDR",     /* name */
+        FALSE,                 /* partial_inplace */
+        0,                     /* src_mask */
+        0,                     /* dst_mask */
+        FALSE),                /* pcrel_offset */
+
  };
  \f
  /* Map BFD reloc types to M32C ELF reloc types.  */
  };
  \f
  /* Map BFD reloc types to M32C ELF reloc types.  */
@@ -146,43 +247,114 @@ static const struct m32c_reloc_map m32c_reloc_map [] =
  {
    { BFD_RELOC_NONE,            R_M32C_NONE },
    { BFD_RELOC_16,              R_M32C_16 },
  {
    { BFD_RELOC_NONE,            R_M32C_NONE },
    { BFD_RELOC_16,              R_M32C_16 },
-  { BFD_RELOC_24,               R_M32C_24 },
+  { BFD_RELOC_24,              R_M32C_24 },
    { BFD_RELOC_32,              R_M32C_32 },
    { BFD_RELOC_32,              R_M32C_32 },
-  { BFD_RELOC_8_PCREL,          R_M32C_8_PCREL },
-  { BFD_RELOC_16_PCREL,         R_M32C_16_PCREL }
+  { BFD_RELOC_8_PCREL,         R_M32C_8_PCREL },
+  { BFD_RELOC_16_PCREL,                R_M32C_16_PCREL },
+  { BFD_RELOC_8,               R_M32C_8 },
+  { BFD_RELOC_LO16,            R_M32C_LO16 },
+  { BFD_RELOC_HI16,            R_M32C_HI16 },
+  { BFD_RELOC_M32C_HI8,                R_M32C_HI8 },
+  { BFD_RELOC_M32C_RL_JUMP,    R_M32C_RL_JUMP },
+  { BFD_RELOC_M32C_RL_1ADDR,   R_M32C_RL_1ADDR },
+  { BFD_RELOC_M32C_RL_2ADDR,   R_M32C_RL_2ADDR }
  };
  
  static reloc_howto_type *
  m32c_reloc_type_lookup
  };
  
  static reloc_howto_type *
  m32c_reloc_type_lookup
-    (bfd *                    abfd ATTRIBUTE_UNUSED,
+    (bfd *                   abfd ATTRIBUTE_UNUSED,
       bfd_reloc_code_real_type code)
  {
    unsigned int i;
  
       bfd_reloc_code_real_type code)
  {
    unsigned int i;
  
-  for (i = ARRAY_SIZE (m32c_reloc_map); --i;)
+  for (i = ARRAY_SIZE (m32c_reloc_map); i--;)
      if (m32c_reloc_map [i].bfd_reloc_val == code)
        return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val];
      if (m32c_reloc_map [i].bfd_reloc_val == code)
        return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val];
-  
+
+  return NULL;
+}
+
+static reloc_howto_type *
+m32c_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
+{
+  unsigned int i;
+
+  for (i = 0;
+       i < sizeof (m32c_elf_howto_table) / sizeof (m32c_elf_howto_table[0]);
+       i++)
+    if (m32c_elf_howto_table[i].name != NULL
+       && strcasecmp (m32c_elf_howto_table[i].name, r_name) == 0)
+      return &m32c_elf_howto_table[i];
+
    return NULL;
  }
  
  /* Set the howto pointer for an M32C ELF reloc.  */
  
    return NULL;
  }
  
  /* Set the howto pointer for an M32C ELF reloc.  */
  
-static void
-m32c_info_to_howto_rela
-    (bfd *               abfd ATTRIBUTE_UNUSED,
-     arelent *           cache_ptr,
-     Elf_Internal_Rela * dst)
+static bfd_boolean
+m32c_info_to_howto_rela (bfd *               abfd,
+                        arelent *           cache_ptr,
+                        Elf_Internal_Rela * dst)
  {
    unsigned int r_type;
  
    r_type = ELF32_R_TYPE (dst->r_info);
  {
    unsigned int r_type;
  
    r_type = ELF32_R_TYPE (dst->r_info);
-  BFD_ASSERT (r_type < (unsigned int) R_M32C_max);
+  if (r_type >= (unsigned int) R_M32C_max)
+    {
+      /* xgettext:c-format */
+      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+                         abfd, r_type);
+      bfd_set_error (bfd_error_bad_value);
+      return FALSE;
+    }
    cache_ptr->howto = & m32c_elf_howto_table [r_type];
    cache_ptr->howto = & m32c_elf_howto_table [r_type];
+  return TRUE;
  }
  
  \f
  
  }
  
  \f
  
+/* Apply R_M32C_24 relocations.  We have to do this because it's not a
+   power-of-two size, and the generic code may think it overruns the
+   section if it's right at the end.
+
+   Must return something other than bfd_reloc_continue to avoid the
+   above problem.  Typical return values include bfd_reloc_ok or
+   bfd_reloc_overflow.
+*/
+
+static bfd_reloc_status_type m32c_apply_reloc_24 (bfd *abfd ATTRIBUTE_UNUSED,
+                                                 arelent *reloc_entry,
+                                                 asymbol *symbol,
+                                                 void *vdata_start ATTRIBUTE_UNUSED,
+                                                 asection *input_section,
+                                                 bfd *ibfd ATTRIBUTE_UNUSED,
+                                                 char **error_msg ATTRIBUTE_UNUSED)
+{
+  bfd_vma relocation;
+  bfd_reloc_status_type s;
+
+  s = bfd_elf_generic_reloc (abfd, reloc_entry, symbol,
+                            vdata_start,
+                            input_section, ibfd, error_msg);
+  if (s != bfd_reloc_continue)
+    return s;
+
+  /* Get symbol value.  (Common symbols are special.)  */
+  if (bfd_is_com_section (symbol->section))
+    relocation = 0;
+  else
+    relocation = symbol->value;
+
+  relocation += symbol->section->output_offset;
+
+  /* Add in supplied addend.  */
+  relocation += reloc_entry->addend;
+
+  reloc_entry->addend = relocation;
+  reloc_entry->address += input_section->output_offset;
+  return bfd_reloc_ok;
+}
+
  /* Relocate an M32C ELF section.
     There is some attempt to make this function usable for many architectures,
     both USE_REL and USE_RELA ['twould be nice if such a critter existed],
  /* Relocate an M32C ELF section.
     There is some attempt to make this function usable for many architectures,
     both USE_REL and USE_RELA ['twould be nice if such a critter existed],
@@ -218,73 +390,56 @@ m32c_info_to_howto_rela
  
  static bfd_boolean
  m32c_elf_relocate_section
  
  static bfd_boolean
  m32c_elf_relocate_section
-    (bfd *                   output_bfd ATTRIBUTE_UNUSED,
+    (bfd *                  output_bfd ATTRIBUTE_UNUSED,
       struct bfd_link_info *  info,
       struct bfd_link_info *  info,
-     bfd *                   input_bfd,
-     asection *              input_section,
-     bfd_byte *              contents,
+     bfd *                  input_bfd,
+     asection *                     input_section,
+     bfd_byte *                     contents,
       Elf_Internal_Rela *     relocs,
       Elf_Internal_Rela *     relocs,
-     Elf_Internal_Sym *      local_syms,
-     asection **             local_sections)
+     Elf_Internal_Sym *             local_syms,
+     asection **            local_sections)
  {
  {
-  Elf_Internal_Shdr *           symtab_hdr;
+  Elf_Internal_Shdr *          symtab_hdr;
    struct elf_link_hash_entry ** sym_hashes;
    struct elf_link_hash_entry ** sym_hashes;
-  Elf_Internal_Rela *           rel;
-  Elf_Internal_Rela *           relend;
-  bfd *dynobj;
+  Elf_Internal_Rela *          rel;
+  Elf_Internal_Rela *          relend;
    asection *splt;
  
    symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
    sym_hashes = elf_sym_hashes (input_bfd);
    relend     = relocs + input_section->reloc_count;
  
    asection *splt;
  
    symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
    sym_hashes = elf_sym_hashes (input_bfd);
    relend     = relocs + input_section->reloc_count;
  
-  dynobj = elf_hash_table (info)->dynobj;
-  splt = NULL;
-  if (dynobj != NULL)
-    splt = bfd_get_section_by_name (dynobj, ".plt");
+  splt = elf_hash_table (info)->splt;
  
    for (rel = relocs; rel < relend; rel ++)
      {
  
    for (rel = relocs; rel < relend; rel ++)
      {
-      reloc_howto_type *           howto;
-      unsigned long                r_symndx;
-      Elf_Internal_Sym *           sym;
-      asection *                   sec;
+      reloc_howto_type *          howto;
+      unsigned long               r_symndx;
+      Elf_Internal_Sym *          sym;
+      asection *                  sec;
        struct elf_link_hash_entry * h;
        struct elf_link_hash_entry * h;
-      bfd_vma                      relocation;
-      bfd_reloc_status_type        r;
-      const char *                 name = NULL;
-      int                          r_type;
-      
+      bfd_vma                     relocation;
+      bfd_reloc_status_type       r;
+      const char *                name = NULL;
+      int                         r_type;
+
        r_type = ELF32_R_TYPE (rel->r_info);
        r_type = ELF32_R_TYPE (rel->r_info);
-      
-      r_symndx = ELF32_R_SYM (rel->r_info);
  
  
-      if (info->relocatable)
-       {
-         /* This is a relocatable link.  We don't have to change
-             anything, unless the reloc is against a section symbol,
-             in which case we have to adjust according to where the
-             section symbol winds up in the output section.  */
-         if (r_symndx < symtab_hdr->sh_info)
-           {
-             sym = local_syms + r_symndx;
-             
-             if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
-               {
-                 sec = local_sections [r_symndx];
-                 rel->r_addend += sec->output_offset + sym->st_value;
-               }
-           }
+      /* These are only used for relaxing; we don't actually relocate
+        anything with them, so skip them.  */
+      if (r_type == R_M32C_RL_JUMP
+         || r_type == R_M32C_RL_1ADDR
+         || r_type == R_M32C_RL_2ADDR)
+       continue;
  
  
-         continue;
-       }
+      r_symndx = ELF32_R_SYM (rel->r_info);
  
  
-      /* This is a final link.  */
        howto  = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info);
        h      = NULL;
        sym    = NULL;
        sec    = NULL;
        howto  = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info);
        h      = NULL;
        sym    = NULL;
        sec    = NULL;
-      
+      relocation = 0;
+
        if (r_symndx < symtab_hdr->sh_info)
         {
           sym = local_syms + r_symndx;
        if (r_symndx < symtab_hdr->sh_info)
         {
           sym = local_syms + r_symndx;
@@ -292,21 +447,26 @@ m32c_elf_relocate_section
           relocation = (sec->output_section->vma
                         + sec->output_offset
                         + sym->st_value);
           relocation = (sec->output_section->vma
                         + sec->output_offset
                         + sym->st_value);
-         
+
           name = bfd_elf_string_from_elf_section
             (input_bfd, symtab_hdr->sh_link, sym->st_name);
           name = bfd_elf_string_from_elf_section
             (input_bfd, symtab_hdr->sh_link, sym->st_name);
-         name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
+         name = sym->st_name == 0 ? bfd_section_name (sec) : name;
         }
        else
         {
           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
         }
        else
         {
           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
-         
+
+         if (info->wrap_hash != NULL
+             && (input_section->flags & SEC_DEBUGGING) != 0)
+           h = ((struct elf_link_hash_entry *)
+                unwrap_hash_lookup (info, input_bfd, &h->root));
+
           while (h->root.type == bfd_link_hash_indirect
                  || h->root.type == bfd_link_hash_warning)
             h = (struct elf_link_hash_entry *) h->root.u.i.link;
  
           name = h->root.root.string;
           while (h->root.type == bfd_link_hash_indirect
                  || h->root.type == bfd_link_hash_warning)
             h = (struct elf_link_hash_entry *) h->root.u.i.link;
  
           name = h->root.root.string;
-         
+
           if (h->root.type == bfd_link_hash_defined
               || h->root.type == bfd_link_hash_defweak)
             {
           if (h->root.type == bfd_link_hash_defined
               || h->root.type == bfd_link_hash_defweak)
             {
@@ -316,17 +476,26 @@ m32c_elf_relocate_section
                             + sec->output_offset);
             }
           else if (h->root.type == bfd_link_hash_undefweak)
                             + sec->output_offset);
             }
           else if (h->root.type == bfd_link_hash_undefweak)
-           {
-             relocation = 0;
-           }
-         else
-           {
-             if (! ((*info->callbacks->undefined_symbol)
-                    (info, h->root.root.string, input_bfd,
-                     input_section, rel->r_offset, TRUE)))
-               return FALSE;
-             relocation = 0;
-           }
+           ;
+         else if (!bfd_link_relocatable (info))
+           (*info->callbacks->undefined_symbol) (info, h->root.root.string,
+                                                 input_bfd, input_section,
+                                                 rel->r_offset, TRUE);
+       }
+
+      if (sec != NULL && discarded_section (sec))
+       RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+                                        rel, 1, relend, howto, 0, contents);
+
+      if (bfd_link_relocatable (info))
+       {
+         /* This is a relocatable link.  We don't have to change
+            anything, unless the reloc is against a section symbol,
+            in which case we have to adjust according to where the
+            section symbol winds up in the output section.  */
+         if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+           rel->r_addend += sec->output_offset;
+         continue;
         }
  
        switch (ELF32_R_TYPE (rel->r_info))
         }
  
        switch (ELF32_R_TYPE (rel->r_info))
@@ -344,9 +513,9 @@ m32c_elf_relocate_section
                     relocation, *plt_offset);*/
             if (relocation <= 0xffff)
               {
                     relocation, *plt_offset);*/
             if (relocation <= 0xffff)
               {
-               /* If the symbol is in range for a 16-bit address, we should
+               /* If the symbol is in range for a 16-bit address, we should
                    have deallocated the plt entry in relax_section.  */
                    have deallocated the plt entry in relax_section.  */
-               BFD_ASSERT (*plt_offset == (bfd_vma) -1);
+               BFD_ASSERT (*plt_offset == (bfd_vma) -1);
               }
             else
               {
               }
             else
               {
@@ -369,14 +538,70 @@ m32c_elf_relocate_section
                 relocation = (splt->output_section->vma
                               + splt->output_offset
                               + (*plt_offset & -2));
                 relocation = (splt->output_section->vma
                               + splt->output_offset
                               + (*plt_offset & -2));
+               if (name)
+               {
+                 char *newname = bfd_malloc (strlen(name)+5);
+                 strcpy (newname, name);
+                 strcat(newname, ".plt");
+                 _bfd_generic_link_add_one_symbol (info,
+                                                   input_bfd,
+                                                   newname,
+                                                   BSF_FUNCTION | BSF_WEAK,
+                                                   splt,
+                                                   (*plt_offset & -2),
+                                                   0,
+                                                   1,
+                                                   0,
+                                                   0);
+               }
               }
           }
           break;
               }
           }
           break;
+
+       case R_M32C_HI8:
+       case R_M32C_HI16:
+         relocation >>= 16;
+         break;
         }
  
         }
  
-      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
-                                    contents, rel->r_offset, relocation,
-                                    rel->r_addend);
+#if 0
+      printf ("relocate %s at %06lx relocation %06lx addend %ld  ",
+             m32c_elf_howto_table[ELF32_R_TYPE(rel->r_info)].name,
+             rel->r_offset + input_section->output_section->vma + input_section->output_offset,
+             relocation, rel->r_addend);
+      {
+       int i;
+       for (i=0; i<4; i++)
+         printf (" %02x", contents[rel->r_offset+i]);
+       printf ("\n");
+      }
+#endif
+      switch (ELF32_R_TYPE(rel->r_info))
+       {
+       case R_M32C_24:
+         /* Like m32c_apply_reloc_24, we must handle this one separately.  */
+         relocation += rel->r_addend;
+
+         /* Sanity check the address.  */
+         if (rel->r_offset + 3
+             > bfd_get_section_limit_octets (input_bfd, input_section))
+           r = bfd_reloc_outofrange;
+         else
+           {
+             bfd_put_8 (input_bfd, relocation & 0xff, contents + rel->r_offset);
+             bfd_put_8 (input_bfd, (relocation >> 8) & 0xff, contents + rel->r_offset + 1);
+             bfd_put_8 (input_bfd, (relocation >> 16) & 0xff, contents + rel->r_offset + 2);
+             r = bfd_reloc_ok;
+           }
+
+         break;
+
+       default:
+         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+                                       contents, rel->r_offset, relocation,
+                                       rel->r_addend);
+         break;
+       }
  
        if (r != bfd_reloc_ok)
         {
  
        if (r != bfd_reloc_ok)
         {
@@ -385,17 +610,16 @@ m32c_elf_relocate_section
           switch (r)
             {
             case bfd_reloc_overflow:
           switch (r)
             {
             case bfd_reloc_overflow:
-             r = info->callbacks->reloc_overflow
+             (*info->callbacks->reloc_overflow)
                 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
                  input_bfd, input_section, rel->r_offset);
               break;
                 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
                  input_bfd, input_section, rel->r_offset);
               break;
-             
+
             case bfd_reloc_undefined:
             case bfd_reloc_undefined:
-             r = info->callbacks->undefined_symbol
-               (info, name, input_bfd, input_section, rel->r_offset,
-                TRUE);
+             (*info->callbacks->undefined_symbol)
+               (info, name, input_bfd, input_section, rel->r_offset, TRUE);
               break;
               break;
-             
+
             case bfd_reloc_outofrange:
               msg = _("internal error: out of range error");
               break;
             case bfd_reloc_outofrange:
               msg = _("internal error: out of range error");
               break;
@@ -414,115 +638,51 @@ m32c_elf_relocate_section
             }
  
           if (msg)
             }
  
           if (msg)
-           r = info->callbacks->warning
-             (info, msg, name, input_bfd, input_section, rel->r_offset);
-
-         if (! r)
-           return FALSE;
+           (*info->callbacks->warning) (info, msg, name, input_bfd,
+                                        input_section, rel->r_offset);
         }
      }
  
    return TRUE;
  }
  \f
         }
      }
  
    return TRUE;
  }
  \f
-/* Return the section that should be marked against GC for a given
-   relocation.  */
-
-static asection *
-m32c_elf_gc_mark_hook
-    (asection *                   sec,
-     struct bfd_link_info *       info ATTRIBUTE_UNUSED,
-     Elf_Internal_Rela *          rel,
-     struct elf_link_hash_entry * h,
-     Elf_Internal_Sym *           sym)
-{
-  if (h != NULL)
-    {
-      switch (ELF32_R_TYPE (rel->r_info))
-       {
-       default:
-         switch (h->root.type)
-           {
-           case bfd_link_hash_defined:
-           case bfd_link_hash_defweak:
-             return h->root.u.def.section;
-
-           case bfd_link_hash_common:
-             return h->root.u.c.p->section;
-
-           default:
-             break;
-           }
-       }
-    }
-  else
-    {
-      if (!(elf_bad_symtab (sec->owner)
-           && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
-         && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
-               && sym->st_shndx != SHN_COMMON))
-       {
-         return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
-       }
-    }
-
-  return NULL;
-}
-
-/* Update the got entry reference counts for the section being removed.  */
-
-static bfd_boolean
-m32c_elf_gc_sweep_hook
-    (bfd *                     abfd ATTRIBUTE_UNUSED,
-     struct bfd_link_info *    info ATTRIBUTE_UNUSED,
-     asection *                sec ATTRIBUTE_UNUSED,
-     const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
-{
-  return TRUE;
-}
-
  /* We support 16-bit pointers to code above 64k by generating a thunk
     below 64k containing a JMP instruction to the final address.  */
  /* We support 16-bit pointers to code above 64k by generating a thunk
     below 64k containing a JMP instruction to the final address.  */
- 
+
  static bfd_boolean
  m32c_elf_check_relocs
  static bfd_boolean
  m32c_elf_check_relocs
-    (bfd *                     abfd,
+    (bfd *                    abfd,
       struct bfd_link_info *    info,
       struct bfd_link_info *    info,
-     asection *                sec,
+     asection *                       sec,
       const Elf_Internal_Rela * relocs)
  {
       const Elf_Internal_Rela * relocs)
  {
-  Elf_Internal_Shdr *           symtab_hdr;
+  Elf_Internal_Shdr *          symtab_hdr;
    struct elf_link_hash_entry ** sym_hashes;
    struct elf_link_hash_entry ** sym_hashes;
-  struct elf_link_hash_entry ** sym_hashes_end;
-  const Elf_Internal_Rela *     rel;
-  const Elf_Internal_Rela *     rel_end;
+  const Elf_Internal_Rela *    rel;
+  const Elf_Internal_Rela *    rel_end;
    bfd_vma *local_plt_offsets;
    asection *splt;
    bfd *dynobj;
    bfd_vma *local_plt_offsets;
    asection *splt;
    bfd *dynobj;
- 
-  if (info->relocatable)
+
+  if (bfd_link_relocatable (info))
      return TRUE;
      return TRUE;
- 
+
    symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
    sym_hashes = elf_sym_hashes (abfd);
    local_plt_offsets = elf_local_got_offsets (abfd);
    splt = NULL;
    dynobj = elf_hash_table(info)->dynobj;
  
    symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
    sym_hashes = elf_sym_hashes (abfd);
    local_plt_offsets = elf_local_got_offsets (abfd);
    splt = NULL;
    dynobj = elf_hash_table(info)->dynobj;
  
-  sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
-  if (!elf_bad_symtab (abfd))
-    sym_hashes_end -= symtab_hdr->sh_info;
- 
    rel_end = relocs + sec->reloc_count;
    for (rel = relocs; rel < rel_end; rel++)
      {
        struct elf_link_hash_entry *h;
        unsigned long r_symndx;
        bfd_vma *offset;
    rel_end = relocs + sec->reloc_count;
    for (rel = relocs; rel < rel_end; rel++)
      {
        struct elf_link_hash_entry *h;
        unsigned long r_symndx;
        bfd_vma *offset;
- 
+
        r_symndx = ELF32_R_SYM (rel->r_info);
        if (r_symndx < symtab_hdr->sh_info)
        r_symndx = ELF32_R_SYM (rel->r_info);
        if (r_symndx < symtab_hdr->sh_info)
-        h = NULL;
+       h = NULL;
        else
         {
           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
        else
         {
           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
@@ -530,33 +690,27 @@ m32c_elf_check_relocs
                  || h->root.type == bfd_link_hash_warning)
             h = (struct elf_link_hash_entry *) h->root.u.i.link;
         }
                  || h->root.type == bfd_link_hash_warning)
             h = (struct elf_link_hash_entry *) h->root.u.i.link;
         }
- 
+
        switch (ELF32_R_TYPE (rel->r_info))
        switch (ELF32_R_TYPE (rel->r_info))
-        {
+       {
           /* This relocation describes a 16-bit pointer to a function.
              We may need to allocate a thunk in low memory; reserve memory
              for it now.  */
         case R_M32C_16:
           if (dynobj == NULL)
             elf_hash_table (info)->dynobj = dynobj = abfd;
           /* This relocation describes a 16-bit pointer to a function.
              We may need to allocate a thunk in low memory; reserve memory
              for it now.  */
         case R_M32C_16:
           if (dynobj == NULL)
             elf_hash_table (info)->dynobj = dynobj = abfd;
+         splt = elf_hash_table (info)->splt;
           if (splt == NULL)
             {
           if (splt == NULL)
             {
-             splt = bfd_get_section_by_name (dynobj, ".plt");
-             if (splt == NULL)
-               {
-                 splt = bfd_make_section (dynobj, ".plt");
-                 if (splt == NULL
-                     || ! bfd_set_section_flags (dynobj, splt,
-                                                 (SEC_ALLOC
-                                                  | SEC_LOAD
-                                                  | SEC_HAS_CONTENTS
-                                                  | SEC_IN_MEMORY
-                                                  | SEC_LINKER_CREATED
-                                                  | SEC_READONLY
-                                                  | SEC_CODE))
-                     || ! bfd_set_section_alignment (dynobj, splt, 1))
-                   return FALSE;
-               }
+             flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+                               | SEC_IN_MEMORY | SEC_LINKER_CREATED
+                               | SEC_READONLY | SEC_CODE);
+             splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
+                                                        flags);
+             elf_hash_table (info)->splt = splt;
+             if (splt == NULL
+                 || !bfd_set_section_alignment (splt, 1))
+               return FALSE;
             }
  
           if (h != NULL)
             }
  
           if (h != NULL)
@@ -586,9 +740,9 @@ m32c_elf_check_relocs
               splt->size += 4;
             }
           break;
               splt->size += 4;
             }
           break;
-        }
+       }
      }
      }
- 
+
    return TRUE;
  }
  
    return TRUE;
  }
  
@@ -596,16 +750,15 @@ m32c_elf_check_relocs
  
  static bfd_boolean
  m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
  
  static bfd_boolean
  m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
-                                  struct bfd_link_info *info)
+                                 struct bfd_link_info *info)
  {
  {
-  bfd *dynobj;
-  asection *splt;
+  bfd *dynobj = elf_hash_table (info)->dynobj;
+  asection *splt = elf_hash_table (info)->splt;
  
    /* As an extra sanity check, verify that all plt entries have
       been filled in.  */
  
  
    /* As an extra sanity check, verify that all plt entries have
       been filled in.  */
  
-  if ((dynobj = elf_hash_table (info)->dynobj) != NULL
-      && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
+  if (dynobj != NULL && splt != NULL)
      {
        bfd_byte *contents = splt->contents;
        unsigned int i, size = splt->size;
      {
        bfd_byte *contents = splt->contents;
        unsigned int i, size = splt->size;
@@ -621,19 +774,19 @@ m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
  
  static bfd_boolean
  m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
  
  static bfd_boolean
  m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
-                               struct bfd_link_info *info)
+                              struct bfd_link_info *info)
  {
    bfd *dynobj;
    asection *splt;
  
  {
    bfd *dynobj;
    asection *splt;
  
-  if (info->relocatable)
+  if (bfd_link_relocatable (info))
      return TRUE;
  
    dynobj = elf_hash_table (info)->dynobj;
    if (dynobj == NULL)
      return TRUE;
  
      return TRUE;
  
    dynobj = elf_hash_table (info)->dynobj;
    if (dynobj == NULL)
      return TRUE;
  
-  splt = bfd_get_section_by_name (dynobj, ".plt");
+  splt = elf_hash_table (info)->splt;
    BFD_ASSERT (splt != NULL);
  
    splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
    BFD_ASSERT (splt != NULL);
  
    splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
@@ -657,8 +810,9 @@ m32c_elf_set_private_flags (bfd *abfd, flagword flags)
     object file when linking.  */
  
  static bfd_boolean
     object file when linking.  */
  
  static bfd_boolean
-m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+m32c_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
  {
  {
+  bfd *obfd = info->output_bfd;
    flagword old_flags, old_partial;
    flagword new_flags, new_partial;
    bfd_boolean error = FALSE;
    flagword old_flags, old_partial;
    flagword new_flags, new_partial;
    bfd_boolean error = FALSE;
@@ -670,9 +824,10 @@ m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
    old_flags = elf_elfheader (obfd)->e_flags;
  
  #ifdef DEBUG
    old_flags = elf_elfheader (obfd)->e_flags;
  
  #ifdef DEBUG
-  (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
-                        old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
-                        bfd_get_filename (ibfd));
+  _bfd_error_handler
+    ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %s",
+     old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
+     bfd_get_filename (ibfd));
  #endif
  
    if (!elf_flags_init (obfd))
  #endif
  
    if (!elf_flags_init (obfd))
@@ -711,14 +866,15 @@ m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
             case EF_M32C_CPU_M32C:  strcat (old_opt, " -m32c");  break;
             }
         }
             case EF_M32C_CPU_M32C:  strcat (old_opt, " -m32c");  break;
             }
         }
-      
+
        /* Print out any mismatches from above.  */
        if (new_opt[0])
         {
           error = TRUE;
        /* Print out any mismatches from above.  */
        if (new_opt[0])
         {
           error = TRUE;
-         (*_bfd_error_handler)
-           (_("%s: compiled with %s and linked with modules compiled with %s"),
-            bfd_get_filename (ibfd), new_opt, old_opt);
+         _bfd_error_handler
+           /* xgettext:c-format */
+           (_("%pB: compiled with %s and linked with modules compiled with %s"),
+            ibfd, new_opt, old_opt);
         }
  
        new_flags &= ~ EF_M32C_ALL_FLAGS;
         }
  
        new_flags &= ~ EF_M32C_ALL_FLAGS;
@@ -728,9 +884,11 @@ m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
        if (new_flags != old_flags)
         {
           error = TRUE;
        if (new_flags != old_flags)
         {
           error = TRUE;
-         (*_bfd_error_handler)
-           (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
-            bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
+         _bfd_error_handler
+           /* xgettext:c-format */
+           (_("%pB: uses different e_flags (%#x) fields"
+              " than previous modules (%#x)"),
+            ibfd, new_flags, old_flags);
         }
      }
  
         }
      }
  
@@ -742,7 +900,7 @@ m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
  
  \f
  static bfd_boolean
  
  \f
  static bfd_boolean
-m32c_elf_print_private_bfd_data (bfd *abfd, PTR ptr)
+m32c_elf_print_private_bfd_data (bfd *abfd, void *ptr)
  {
    FILE *file = (FILE *) ptr;
    flagword flags;
  {
    FILE *file = (FILE *) ptr;
    flagword flags;
@@ -753,7 +911,7 @@ m32c_elf_print_private_bfd_data (bfd *abfd, PTR ptr)
    _bfd_elf_print_private_bfd_data (abfd, ptr);
  
    flags = elf_elfheader (abfd)->e_flags;
    _bfd_elf_print_private_bfd_data (abfd, ptr);
  
    flags = elf_elfheader (abfd)->e_flags;
-  fprintf (file, _("private flags = 0x%lx:"), (long)flags);
+  fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
  
    switch (flags & EF_M32C_CPU_MASK)
      {
  
    switch (flags & EF_M32C_CPU_MASK)
      {
@@ -774,7 +932,7 @@ elf32_m32c_machine (bfd *abfd)
    switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK)
      {
      case EF_M32C_CPU_M16C:     return bfd_mach_m16c;
    switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK)
      {
      case EF_M32C_CPU_M16C:     return bfd_mach_m16c;
-    case EF_M32C_CPU_M32C:     return bfd_mach_m32c;
+    case EF_M32C_CPU_M32C:     return bfd_mach_m32c;
      }
  
    return bfd_mach_m16c;
      }
  
    return bfd_mach_m16c;
@@ -790,7 +948,7 @@ m32c_elf_object_p (bfd *abfd)
   \f
  
  #ifdef DEBUG
   \f
  
  #ifdef DEBUG
-static void
+void
  dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
  {
    size_t locsymcount;
  dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
  {
    size_t locsymcount;
@@ -814,7 +972,7 @@ dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
        external_syms = bfd_malloc (1000);
        free_external = 1;
      }
        external_syms = bfd_malloc (1000);
        free_external = 1;
      }
-  
+
    symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
    locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
    if (free_internal)
    symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
    locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
    if (free_internal)
@@ -829,38 +987,83 @@ dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
      {
        switch (ELF_ST_TYPE (isym->st_info))
         {
      {
        switch (ELF_ST_TYPE (isym->st_info))
         {
-       case STT_FUNC: st_info_str = "STT_FUNC";
-       case STT_SECTION: st_info_str = "STT_SECTION";
-       case STT_SRELC: st_info_str = "STT_SRELC";
-       case STT_FILE: st_info_str = "STT_FILE";
-       case STT_OBJECT: st_info_str = "STT_OBJECT";
-       case STT_TLS: st_info_str = "STT_TLS";
-       default: st_info_str = "";
+       case STT_FUNC:
+         st_info_str = "STT_FUNC";
+         break;
+
+       case STT_SECTION:
+         st_info_str = "STT_SECTION";
+         break;
+
+       case STT_FILE:
+         st_info_str = "STT_FILE";
+         break;
+
+       case STT_OBJECT:
+         st_info_str = "STT_OBJECT";
+         break;
+
+       case STT_TLS:
+         st_info_str = "STT_TLS";
+         break;
+
+       default:
+         st_info_str = "";
         }
         }
+
        switch (ELF_ST_BIND (isym->st_info))
         {
        switch (ELF_ST_BIND (isym->st_info))
         {
-       case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
-       case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
-       default: st_info_stb_str = "";
+       case STB_LOCAL:
+         st_info_stb_str = "STB_LOCAL";
+         break;
+
+       case STB_GLOBAL:
+         st_info_stb_str = "STB_GLOBAL";
+         break;
+
+       default:
+         st_info_stb_str = "";
         }
         }
+
        switch (ELF_ST_VISIBILITY (isym->st_other))
         {
        switch (ELF_ST_VISIBILITY (isym->st_other))
         {
-       case STV_DEFAULT: st_other_str = "STV_DEFAULT";
-       case STV_INTERNAL: st_other_str = "STV_INTERNAL";
-       case STV_PROTECTED: st_other_str = "STV_PROTECTED";
-       default: st_other_str = "";
+       case STV_DEFAULT:
+         st_other_str = "STV_DEFAULT";
+         break;
+
+       case STV_INTERNAL:
+         st_other_str = "STV_INTERNAL";
+         break;
+
+       case STV_PROTECTED:
+         st_other_str = "STV_PROTECTED";
+         break;
+
+       default:
+         st_other_str = "";
         }
         }
+
        switch (isym->st_shndx)
         {
        switch (isym->st_shndx)
         {
-       case SHN_ABS: st_shndx_str = "SHN_ABS";
-       case SHN_COMMON: st_shndx_str = "SHN_COMMON";
-       case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
-       default: st_shndx_str = "";
+       case SHN_ABS:
+         st_shndx_str = "SHN_ABS";
+         break;
+
+       case SHN_COMMON:
+         st_shndx_str = "SHN_COMMON";
+         break;
+
+       case SHN_UNDEF:
+         st_shndx_str = "SHN_UNDEF";
+         break;
+
+       default:
+         st_shndx_str = "";
         }
         }
-      
+
        printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
               "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
        printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
               "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
-             isym, 
+             isym,
               (unsigned long) isym->st_value,
               (unsigned long) isym->st_size,
               isym->st_name,
               (unsigned long) isym->st_value,
               (unsigned long) isym->st_size,
               isym->st_name,
@@ -876,7 +1079,7 @@ dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
      free (external_syms);
  }
  
      free (external_syms);
  }
  
-static char *
+char *
  m32c_get_reloc (long reloc)
  {
    if (0 <= reloc && reloc < R_M32C_max)
  m32c_get_reloc (long reloc)
  {
    if (0 <= reloc && reloc < R_M32C_max)
@@ -898,14 +1101,10 @@ struct relax_plt_data
  };
  
  static bfd_boolean
  };
  
  static bfd_boolean
-m32c_relax_plt_check (struct elf_link_hash_entry *h,
-                      PTR xdata)
+m32c_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
  {
    struct relax_plt_data *data = (struct relax_plt_data *) xdata;
  
  {
    struct relax_plt_data *data = (struct relax_plt_data *) xdata;
  
-  if (h->root.type == bfd_link_hash_warning)
-    h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
    if (h->plt.offset != (bfd_vma) -1)
      {
        bfd_vma address;
    if (h->plt.offset != (bfd_vma) -1)
      {
        bfd_vma address;
@@ -933,14 +1132,10 @@ m32c_relax_plt_check (struct elf_link_hash_entry *h,
     previously had a plt entry, give it a new entry offset.  */
  
  static bfd_boolean
     previously had a plt entry, give it a new entry offset.  */
  
  static bfd_boolean
-m32c_relax_plt_realloc (struct elf_link_hash_entry *h,
-                        PTR xdata)
+m32c_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
  {
    bfd_vma *entry = (bfd_vma *) xdata;
  
  {
    bfd_vma *entry = (bfd_vma *) xdata;
  
-  if (h->root.type == bfd_link_hash_warning)
-    h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
    if (h->plt.offset != (bfd_vma) -1)
      {
        h->plt.offset = *entry;
    if (h->plt.offset != (bfd_vma) -1)
      {
        h->plt.offset = *entry;
@@ -951,10 +1146,9 @@ m32c_relax_plt_realloc (struct elf_link_hash_entry *h,
  }
  
  static bfd_boolean
  }
  
  static bfd_boolean
-m32c_elf_relax_plt_section (bfd *dynobj,
-                            asection *splt,
-                            struct bfd_link_info *info,
-                            bfd_boolean *again)
+m32c_elf_relax_plt_section (asection *splt,
+                           struct bfd_link_info *info,
+                           bfd_boolean *again)
  {
    struct relax_plt_data relax_plt_data;
    bfd *ibfd;
  {
    struct relax_plt_data relax_plt_data;
    bfd *ibfd;
@@ -962,12 +1156,7 @@ m32c_elf_relax_plt_section (bfd *dynobj,
    /* Assume nothing changes.  */
    *again = FALSE;
  
    /* Assume nothing changes.  */
    *again = FALSE;
  
-  if (info->relocatable)
-    return TRUE;
-
-  /* We only relax the .plt section at the moment.  */
-  if (dynobj != elf_hash_table (info)->dynobj
-      || strcmp (splt->name, ".plt") != 0)
+  if (bfd_link_relocatable (info))
      return TRUE;
  
    /* Quick check for an empty plt.  */
      return TRUE;
  
    /* Quick check for an empty plt.  */
@@ -983,7 +1172,7 @@ m32c_elf_relax_plt_section (bfd *dynobj,
  
    /* Likewise for local symbols, though that's somewhat less convenient
       as we have to walk the list of input bfds and swap in symbol data.  */
  
    /* Likewise for local symbols, though that's somewhat less convenient
       as we have to walk the list of input bfds and swap in symbol data.  */
-  for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
+  for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
      {
        bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
        Elf_Internal_Shdr *symtab_hdr;
      {
        bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
        Elf_Internal_Shdr *symtab_hdr;
@@ -1057,7 +1246,7 @@ m32c_elf_relax_plt_section (bfd *dynobj,
        elf_link_hash_traverse (elf_hash_table (info),
                               m32c_relax_plt_realloc, &entry);
  
        elf_link_hash_traverse (elf_hash_table (info),
                               m32c_relax_plt_realloc, &entry);
  
-      for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
+      for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
         {
           bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
           unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
         {
           bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
           unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
@@ -1069,7 +1258,7 @@ m32c_elf_relax_plt_section (bfd *dynobj,
           for (idx = 0; idx < nlocals; ++idx)
             if (local_plt_offsets[idx] != (bfd_vma) -1)
               {
           for (idx = 0; idx < nlocals; ++idx)
             if (local_plt_offsets[idx] != (bfd_vma) -1)
               {
-               local_plt_offsets[idx] = entry;
+               local_plt_offsets[idx] = entry;
                 entry += 4;
               }
         }
                 entry += 4;
               }
         }
@@ -1078,191 +1267,188 @@ m32c_elf_relax_plt_section (bfd *dynobj,
    return TRUE;
  }
  
    return TRUE;
  }
  
-struct relax_reloc_s
+static int
+compare_reloc (const void *e1, const void *e2)
  {
  {
-  int machine;
-  int opcode_mask;
-  bfd_vma opcode;              /* original opcode or insn part */
-  int relax_backward;          /* lbound */
-  int relax_forward;           /* hbound */
-  int value_shift;
-  int mask;
-  int new_opcode;              /* new opcode */
-  int old_reloc;               /* old relocation */
-  int new_reloc;               /* new relocation  */
-  int use_pcrel;
-  int delete_n;                /* # bytes differ between original and new */
-};
-static struct relax_reloc_s relax_reloc [] =
-  {
-#if 0
-    {
-      bfd_mach_m16c,
-      0xff,
-      0xfc,                    /* jmp.a */
-      -32768,
-      32767,
-      2,
-      0xffffff00,
-      0xf4,                    /* jmp.w */
-      R_M32C_8_ELABEL24,
-      R_M32C_8_PCREL16,
-      1,
-      1,
-    },
-    {
-      bfd_mach_m32c,
-      0xff,
-      0xcc,                    /* jmp.a */
-      -32768,
-      32767,
-      2,
-      0xffffff00,
-      0xce,                    /* jmp.w */
-      R_M32C_8_ELABEL24,
-      R_M32C_8_PCREL16,
-      1,
-      1,
-    },
-    {
-      bfd_mach_m32c,
-      0xff,
-      0xcd,                    /* jsr.a */
-      -32768,
-      32767,
-      2,
-      0xffffff00,
-      0xcf,                    /* jsr.w */
-      R_M32C_8_ELABEL24,
-      R_M32C_8_PCREL16,
-      1,
-      1,
-    },
-    {
-      bfd_mach_m16c,
-      0xff,
-      0xf4,                    /* jmp.w */
-      -128,
-      127,
-      2,
-      0xffffff00,
-      0xfe,                    /* jmp.b */
-      R_M32C_8_PCREL16,
-      R_M32C_8_PCREL8,
-      1,
-      1,
-    },
-    {
-      bfd_mach_m32c,
-      0xff,
-      0xce,                    /* jmp.w */
-      -128,
-      127,
-      2,
-      0xffffff00,
-      0xbb,                    /* jmp.b */
-      R_M32C_8_PCREL16,
-      R_M32C_8_PCREL8,
-      1,
-      1,
-    },
-    {
-      bfd_mach_m32c,
-      0xc0f6,
-      0x8096,                  /* dest */
-      0,
-      0xffff,
-      3,
-      0xffff3fff,
-      0xc000,                  /* abs16 */
-      R_M32C_24_ABS24,
-      R_M32C_24_ABS16,
-      0,
-      1,
-    },
-    {
-      bfd_mach_m32c,
-      0xc0f6,
-      0x80a6,                  /* dest */
-      0,
-      0xffff,
-      4,
-      0xffff3fff,
-      0xc000,                  /* abs16 */
-      R_M32C_32_ABS24,
-      R_M32C_32_ABS16,
-      0,
-      1,
-    },
-    {
-      bfd_mach_m32c,
-      0xc0f6,
-      0x80b6,                  /* dest */
-      0,
-      0xffff,
-      5,
-      0xffff3fff,
-      0xc000,                  /* abs16 */
-      R_M32C_40_ABS24,
-      R_M32C_40_ABS16,
-      0,
-      1,
-    },
-    {
-      bfd_mach_m32c,
-      0x30f0,
-      0x20b0,                  /* src */
-      0,
-      0xffff,
-      2,
-      0xffffcfff,
-      0x3000,                  /* abs16 */
-      R_M32C_16_ABS24,
-      R_M32C_16_ABS16,
-      0,
-      1,
-    },
+  const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
+  const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
+
+  if (i1->r_offset == i2->r_offset)
+    return 0;
+  else
+    return i1->r_offset < i2->r_offset ? -1 : 1;
+}
+
+#define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
+static bfd_vma
+m32c_offset_for_reloc (bfd *abfd,
+                      Elf_Internal_Rela *rel,
+                      Elf_Internal_Shdr *symtab_hdr,
+                      Elf_External_Sym_Shndx *shndx_buf ATTRIBUTE_UNUSED,
+                      Elf_Internal_Sym *intsyms)
+{
+  bfd_vma symval;
+
+  /* Get the value of the symbol referred to by the reloc.  */
+  if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
      {
      {
-      bfd_mach_m32c,
-      0xc086,
-      0x8086,                  /* dest */
-      0,
-      0xffff,
-      2,
-      0xffff3fff,
-      0xc000,                  /* abs16 */
-      R_M32C_16_ABS24,
-      R_M32C_16_ABS16,
-      0,
-      1,
-    },
-#endif
+      /* A local symbol.  */
+      Elf_Internal_Sym *isym;
+      asection *ssec;
+
+      isym = intsyms + ELF32_R_SYM (rel->r_info);
+      ssec = bfd_section_from_elf_index (abfd, isym->st_shndx);
+      symval = isym->st_value;
+      if (ssec)
+       symval += ssec->output_section->vma
+         + ssec->output_offset;
+    }
+  else
      {
      {
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      unsigned long indx;
+      struct elf_link_hash_entry *h;
+
+      /* An external symbol.  */
+      indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
+      h = elf_sym_hashes (abfd)[indx];
+      BFD_ASSERT (h != NULL);
+
+      if (h->root.type != bfd_link_hash_defined
+         && h->root.type != bfd_link_hash_defweak)
+       /* This appears to be a reference to an undefined
+          symbol.  Just ignore it--it will be caught by the
+          regular reloc processing.  */
+       return 0;
+
+      symval = (h->root.u.def.value
+               + h->root.u.def.section->output_section->vma
+               + h->root.u.def.section->output_offset);
      }
      }
-  };
+  return symval;
+}
+
+static int bytes_saved = 0;
+
+static int bytes_to_reloc[] = {
+  R_M32C_NONE,
+  R_M32C_8,
+  R_M32C_16,
+  R_M32C_24,
+  R_M32C_32
+};
+
+/* What we use the bits in a relax reloc addend (R_M32C_RL_*) for.  */
+
+/* Mask for the number of relocs associated with this insn.  */
+#define RLA_RELOCS             0x0000000f
+/* Number of bytes gas emitted (before gas's relaxing) */
+#define RLA_NBYTES             0x00000ff0
+
+/* If the displacement is within the given range and the new encoding
+   differs from the old encoding (the index), then the insn can be
+   relaxed to the new encoding.  */
+typedef struct {
+  int bytes;
+  unsigned int max_disp;
+  unsigned char new_encoding;
+} EncodingTable;
+
+static EncodingTable m16c_addr_encodings[] = {
+  { 0,   0,  0 }, /* R0 */
+  { 0,   0,  1 }, /* R1 */
+  { 0,   0,  2 }, /* R2 */
+  { 0,   0,  3 }, /* R3 */
+  { 0,   0,  4 }, /* A0 */
+  { 0,   0,  5 }, /* A1 */
+  { 0,   0,  6 }, /* [A0] */
+  { 0,   0,  7 }, /* [A1] */
+  { 1,   0,  6 }, /* udsp:8[A0] */
+  { 1,   0,  7 }, /* udsp:8[A1] */
+  { 1,   0, 10 }, /* udsp:8[SB] */
+  { 1,   0, 11 }, /* sdsp:8[FB] */
+  { 2, 255,  8 }, /* udsp:16[A0] */
+  { 2, 255,  9 }, /* udsp:16[A1] */
+  { 2, 255, 10 }, /* udsp:16[SB] */
+  { 2,   0, 15 }, /* abs:16 */
+};
+
+static EncodingTable m16c_jmpaddr_encodings[] = {
+  { 0,   0,  0 }, /* R0 */
+  { 0,   0,  1 }, /* R1 */
+  { 0,   0,  2 }, /* R2 */
+  { 0,   0,  3 }, /* R3 */
+  { 0,   0,  4 }, /* A0 */
+  { 0,   0,  5 }, /* A1 */
+  { 0,   0,  6 }, /* [A0] */
+  { 0,   0,  7 }, /* [A1] */
+  { 1,   0,  6 }, /* udsp:8[A0] */
+  { 1,   0,  7 }, /* udsp:8[A1] */
+  { 1,   0, 10 }, /* udsp:8[SB] */
+  { 1,   0, 11 }, /* sdsp:8[FB] */
+  { 3, 255,  8 }, /* udsp:20[A0] */
+  { 3, 255,  9 }, /* udsp:20[A1] */
+  { 2, 255, 10 }, /* udsp:16[SB] */
+  { 2,   0, 15 }, /* abs:16 */
+};
+
+static EncodingTable m32c_addr_encodings[] = {
+  { 0,     0,  0 }, /* [A0] */
+  { 0,     0,  1 }, /* [A1] */
+  { 0,     0,  2 }, /* A0 */
+  { 0,     0,  3 }, /* A1 */
+  { 1,     0,  0 }, /* udsp:8[A0] */
+  { 1,     0,  1 }, /* udsp:8[A1] */
+  { 1,     0,  6 }, /* udsp:8[SB] */
+  { 1,     0,  7 }, /* sdsp:8[FB] */
+  { 2,   255,  4 }, /* udsp:16[A0] */
+  { 2,   255,  5 }, /* udsp:16[A1] */
+  { 2,   255,  6 }, /* udsp:16[SB] */
+  { 2,   127,  7 }, /* sdsp:16[FB] */
+  { 3, 65535, 8 }, /* udsp:24[A0] */
+  { 3, 65535, 9 }, /* udsp:24[A1] */
+  { 3, 65535, 15 }, /* abs24 */
+  { 2,     0, 15 }, /* abs16 */
+  { 0,     0, 16 }, /* R2 */
+  { 0,     0, 17 }, /* R3 */
+  { 0,     0, 18 }, /* R0 */
+  { 0,     0, 19 }, /* R1 */
+  { 0,     0, 20 }, /*  */
+  { 0,     0, 21 }, /*  */
+  { 0,     0, 22 }, /*  */
+  { 0,     0, 23 }, /*  */
+  { 0,     0, 24 }, /*  */
+  { 0,     0, 25 }, /*  */
+  { 0,     0, 26 }, /*  */
+  { 0,     0, 27 }, /*  */
+  { 0,     0, 28 }, /*  */
+  { 0,     0, 29 }, /*  */
+  { 0,     0, 30 }, /*  */
+  { 0,     0, 31 }, /*  */
+};
+
  static bfd_boolean
  m32c_elf_relax_section
  static bfd_boolean
  m32c_elf_relax_section
-    (bfd *                  abfd,
-     asection *             sec,
+    (bfd *                 abfd,
+     asection *                    sec,
       struct bfd_link_info * link_info,
       struct bfd_link_info * link_info,
-     bfd_boolean *          again)
+     bfd_boolean *         again)
  {
    Elf_Internal_Shdr *symtab_hdr;
    Elf_Internal_Shdr *shndx_hdr;
    Elf_Internal_Rela *internal_relocs;
    Elf_Internal_Rela *free_relocs = NULL;
  {
    Elf_Internal_Shdr *symtab_hdr;
    Elf_Internal_Shdr *shndx_hdr;
    Elf_Internal_Rela *internal_relocs;
    Elf_Internal_Rela *free_relocs = NULL;
-  Elf_Internal_Rela *irel, *irelend;
+  Elf_Internal_Rela *irel, *irelend, *srel;
    bfd_byte * contents = NULL;
    bfd_byte * free_contents = NULL;
    bfd_byte * contents = NULL;
    bfd_byte * free_contents = NULL;
-  Elf32_External_Sym *extsyms = NULL;
-  Elf32_External_Sym *free_extsyms = NULL;
+  Elf_Internal_Sym *intsyms = NULL;
+  Elf_Internal_Sym *free_intsyms = NULL;
    Elf_External_Sym_Shndx *shndx_buf = NULL;
    int machine;
  
    if (abfd == elf_hash_table (link_info)->dynobj
    Elf_External_Sym_Shndx *shndx_buf = NULL;
    int machine;
  
    if (abfd == elf_hash_table (link_info)->dynobj
+      && (sec->flags & SEC_LINKER_CREATED) != 0
        && strcmp (sec->name, ".plt") == 0)
        && strcmp (sec->name, ".plt") == 0)
-    return m32c_elf_relax_plt_section (abfd, sec, link_info, again);
+    return m32c_elf_relax_plt_section (sec, link_info, again);
  
    /* Assume nothing changes.  */
    *again = FALSE;
  
    /* Assume nothing changes.  */
    *again = FALSE;
@@ -1272,209 +1458,444 @@ m32c_elf_relax_section
    /* We don't have to do anything for a relocatable link, if
       this section does not have relocs, or if this is not a
       code section.  */
    /* We don't have to do anything for a relocatable link, if
       this section does not have relocs, or if this is not a
       code section.  */
-  if (link_info->relocatable
+  if (bfd_link_relocatable (link_info)
        || (sec->flags & SEC_RELOC) == 0
        || sec->reloc_count == 0
        || (sec->flags & SEC_CODE) == 0)
      return TRUE;
  
        || (sec->flags & SEC_RELOC) == 0
        || sec->reloc_count == 0
        || (sec->flags & SEC_CODE) == 0)
      return TRUE;
  
-  /* Relaxing doesn't quite work right yet.  */
-  return TRUE;
+  symtab_hdr = & elf_symtab_hdr (abfd);
+  if (elf_symtab_shndx_list (abfd))
+    shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
+  else
+    shndx_hdr = NULL;
  
  
-  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
-  shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+  /* Get the section contents.  */
+  if (elf_section_data (sec)->this_hdr.contents != NULL)
+    contents = elf_section_data (sec)->this_hdr.contents;
+  /* Go get them off disk.  */
+  else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
+    goto error_return;
+
+  /* Read this BFD's symbols.  */
+  /* Get cached copy if it exists.  */
+  if (symtab_hdr->contents != NULL)
+    {
+      intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
+    }
+  else
+    {
+      intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
+      symtab_hdr->contents = (bfd_byte *) intsyms;
+    }
+
+  if (shndx_hdr && shndx_hdr->sh_size != 0)
+    {
+      bfd_size_type amt;
+
+      amt = symtab_hdr->sh_info;
+      amt *= sizeof (Elf_External_Sym_Shndx);
+      shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
+      if (shndx_buf == NULL)
+       goto error_return;
+      if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
+         || bfd_bread (shndx_buf, amt, abfd) != amt)
+       goto error_return;
+      shndx_hdr->contents = (bfd_byte *) shndx_buf;
+    }
  
    /* Get a copy of the native relocations.  */
    internal_relocs = (_bfd_elf_link_read_relocs
  
    /* Get a copy of the native relocations.  */
    internal_relocs = (_bfd_elf_link_read_relocs
-                    (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
+                    (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
                       link_info->keep_memory));
    if (internal_relocs == NULL)
      goto error_return;
    if (! link_info->keep_memory)
      free_relocs = internal_relocs;
  
                       link_info->keep_memory));
    if (internal_relocs == NULL)
      goto error_return;
    if (! link_info->keep_memory)
      free_relocs = internal_relocs;
  
+  /* The RL_ relocs must be just before the operand relocs they go
+     with, so we must sort them to guarantee this.  */
+  qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
+        compare_reloc);
+
    /* Walk through them looking for relaxing opportunities.  */
    irelend = internal_relocs + sec->reloc_count;
  
    for (irel = internal_relocs; irel < irelend; irel++)
      {
        bfd_vma symval;
    /* Walk through them looking for relaxing opportunities.  */
    irelend = internal_relocs + sec->reloc_count;
  
    for (irel = internal_relocs; irel < irelend; irel++)
      {
        bfd_vma symval;
-      bfd_vma insn;
+      unsigned char *insn, *gap, *einsn;
        bfd_vma pc;
        bfd_vma pc;
-      bfd_signed_vma pcrel_value;
-      bfd_vma addend;
-      int to_delete;
-      int i;
+      bfd_signed_vma pcrel;
+      int relax_relocs;
+      int gap_size;
+      int new_type;
+      int posn;
+      int enc;
+      EncodingTable *enctbl;
+      EncodingTable *e;
+
+      if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP
+         && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR
+         && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR)
+       continue;
  
  
-      /* Get the section contents.  */
-      if (contents == NULL)
-       {
-         if (elf_section_data (sec)->this_hdr.contents != NULL)
-           contents = elf_section_data (sec)->this_hdr.contents;
-         /* Go get them off disk.  */
-         else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
-           goto error_return;
-       }
+      srel = irel;
  
  
-      /* Read this BFD's symbols if we haven't done so already.  */
-      if (extsyms == NULL)
+      /* There will always be room for the relaxed insn, since it is smaller
+        than the one it would replace.  */
+      BFD_ASSERT (irel->r_offset < sec->size);
+
+      insn = contents + irel->r_offset;
+      relax_relocs = irel->r_addend % 16;
+
+      /* Ok, we only have three relocs we care about, and they're all
+        fake.  The lower four bits of the addend is always the number
+        of following relocs (hence the qsort above) that are assigned
+        to this opcode.  The next 8 bits of the addend indicates the
+        number of bytes in the insn.  We use the rest of them
+        ourselves as flags for the more expensive operations (defines
+        above).  The three relocs are:
+
+        RL_JUMP: This marks all direct jump insns.  We check the
+               displacement and replace them with shorter jumps if
+               they're in range.  We also use this to find JMP.S
+               insns and manually shorten them when we delete bytes.
+               We have to decode these insns to figure out what to
+               do.
+
+        RL_1ADDR: This is a :G or :Q insn, which has a single
+               "standard" operand.  We have to extract the type
+               field, see if it's a wide displacement, then figure
+               out if we can replace it with a narrow displacement.
+               We don't have to decode these insns.
+
+        RL_2ADDR: Similarly, but two "standard" operands.  Note that
+               r_addend may still be 1, as standard operands don't
+               always have displacements.  Gas shouldn't give us one
+               with zero operands, but since we don't know which one
+               has the displacement, we check them both anyway.
+
+        These all point to the beginning of the insn itself, not the
+        operands.
+
+        Note that we only relax one step at a time, relying on the
+        linker to call us repeatedly.  Thus, there is no code for
+        JMP.A->JMP.B although that will happen in two steps.
+        Likewise, for 2ADDR relaxes, we do one operand per cycle.
+      */
+
+      /* Get the value of the symbol referred to by the reloc.  Just
+        in case this is the last reloc in the list, use the RL's
+        addend to choose between this reloc (no addend) or the next
+        (yes addend, which means at least one following reloc).  */
+      srel = irel + (relax_relocs ? 1 : 0);
+      symval = OFFSET_FOR_RELOC (srel);
+
+      /* Setting gap_size nonzero is the flag which means "something
+        shrunk".  */
+      gap_size = 0;
+      gap = NULL;
+      new_type = ELF32_R_TYPE(srel->r_info);
+
+      pc = sec->output_section->vma + sec->output_offset
+       + srel->r_offset;
+      pcrel = symval - pc + srel->r_addend;
+
+      if (machine == bfd_mach_m16c)
         {
         {
-         /* Get cached copy if it exists.  */
-         if (symtab_hdr->contents != NULL)
-           extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
-         else
-           {
-             bfd_size_type amt = symtab_hdr->sh_size;
-
-             /* Go get them off disk.  */
-             extsyms = (Elf32_External_Sym *) bfd_malloc (amt);
-             if (extsyms == NULL)
-               goto error_return;
-             free_extsyms = extsyms;
-             if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
-                 || bfd_bread (extsyms, amt, abfd) != amt)
-               goto error_return;
-             symtab_hdr->contents = (bfd_byte *) extsyms;
-           }
+         /* R8C / M16C */
  
  
-         if (shndx_hdr->sh_size != 0)
+         switch (ELF32_R_TYPE(irel->r_info))
             {
             {
-             bfd_size_type amt;
-
-             amt = symtab_hdr->sh_info;
-             amt *= sizeof (Elf_External_Sym_Shndx);
-             shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
-             if (shndx_buf == NULL)
-               goto error_return;
-             if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
-                 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
-               goto error_return;
-             shndx_hdr->contents = (bfd_byte *) shndx_buf;
-           }
-       }
  
  
-      /* Get the value of the symbol referred to by the reloc.  */
-      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
-       {
-         /* A local symbol.  */
-         Elf32_External_Sym *esym;
-         Elf_External_Sym_Shndx *shndx;
-         Elf_Internal_Sym isym;
-
-         esym = extsyms + ELF32_R_SYM (irel->r_info);
-         shndx = shndx_buf + (shndx_buf ? ELF32_R_SYM (irel->r_info) : 0);
-         bfd_elf32_swap_symbol_in (abfd, esym, shndx, &isym);
-
-         symval = (isym.st_value
-                   + sec->output_section->vma
-                   + sec->output_offset);
-       }
-      else
-       {
-         unsigned long indx;
-         struct elf_link_hash_entry *h;
-
-         /* An external symbol.  */
-         indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
-         h = elf_sym_hashes (abfd)[indx];
-         BFD_ASSERT (h != NULL);
-
-         if (h->root.type != bfd_link_hash_defined
-             && h->root.type != bfd_link_hash_defweak)
-           /* This appears to be a reference to an undefined
-              symbol.  Just ignore it--it will be caught by the
-              regular reloc processing.  */
-           continue;
+           case R_M32C_RL_JUMP:
+             switch (insn[0])
+               {
+               case 0xfe: /* jmp.b */
+                 if (pcrel >= 2 && pcrel <= 9)
+                   {
+                     /* Relax JMP.B -> JMP.S.  We need to get rid of
+                        the following reloc though. */
+                     insn[0] = 0x60 | (pcrel - 2);
+                     new_type = R_M32C_NONE;
+                     irel->r_addend = 0x10;
+                     gap_size = 1;
+                     gap = insn + 1;
+                   }
+                 break;
+
+               case 0xf4: /* jmp.w */
+                 /* 128 is allowed because it will be one byte closer
+                    after relaxing.  Likewise for all other pc-rel
+                    jumps.  */
+                 if (pcrel <= 128 && pcrel >= -128)
+                   {
+                     /* Relax JMP.W -> JMP.B */
+                     insn[0] = 0xfe;
+                     insn[1] = 0;
+                     new_type = R_M32C_8_PCREL;
+                     gap_size = 1;
+                     gap = insn + 2;
+                   }
+                 break;
+
+               case 0xfc: /* jmp.a */
+                 if (pcrel <= 32768 && pcrel >= -32768)
+                   {
+                     /* Relax JMP.A -> JMP.W */
+                     insn[0] = 0xf4;
+                     insn[1] = 0;
+                     insn[2] = 0;
+                     new_type = R_M32C_16_PCREL;
+                     gap_size = 1;
+                     gap = insn + 3;
+                   }
+                 break;
+
+               case 0xfd: /* jsr.a */
+                 if (pcrel <= 32768 && pcrel >= -32768)
+                   {
+                     /* Relax JSR.A -> JSR.W */
+                     insn[0] = 0xf5;
+                     insn[1] = 0;
+                     insn[2] = 0;
+                     new_type = R_M32C_16_PCREL;
+                     gap_size = 1;
+                     gap = insn + 3;
+                   }
+                 break;
+               }
+             break;
  
  
-         symval = (h->root.u.def.value
-                   + h->root.u.def.section->output_section->vma
-                   + h->root.u.def.section->output_offset);
-       }
+           case R_M32C_RL_2ADDR:
+             /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
  
  
-      /* There will always be room for the relaxed insn, since it is smaller
-        than the one it would replace.  */
-      BFD_ASSERT (irel->r_offset <= sec->size - 2);
+             enctbl = m16c_addr_encodings;
+             posn = 2;
+             enc = (insn[1] >> 4) & 0x0f;
+             e = & enctbl[enc];
+
+             if (srel->r_offset == irel->r_offset + posn
+                 && e->new_encoding != enc
+                 && symval <= e->max_disp)
+               {
+                 insn[1] &= 0x0f;
+                 insn[1] |= e->new_encoding << 4;
+                 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
+                 gap = insn + posn + enctbl[e->new_encoding].bytes;
+                 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
+                 break;
+               }
+             if (relax_relocs == 2)
+               srel ++;
+             posn += e->bytes;
+
+             goto try_1addr_16;
+
+           case R_M32C_RL_1ADDR:
+             /* xxxx xxxx xxxx dest [disp] */
+
+             enctbl = m16c_addr_encodings;
+             posn = 2;
+
+             /* Check the opcode for jumps.  We know it's safe to
+                do this because all 2ADDR insns are at least two
+                bytes long.  */
+             enc = insn[0] * 256 + insn[1];
+             enc &= 0xfff0;
+             if (enc == 0x7d20
+                 || enc == 0x7d00
+                 || enc == 0x7d30
+                 || enc == 0x7d10)
+               {
+                 enctbl = m16c_jmpaddr_encodings;
+               }
+
+           try_1addr_16:
+             /* srel, posn, and enc must be set here.  */
+
+             symval = OFFSET_FOR_RELOC (srel);
+             enc = insn[1] & 0x0f;
+             e = & enctbl[enc];
+
+             if (srel->r_offset == irel->r_offset + posn
+                 && e->new_encoding != enc
+                 && symval <= e->max_disp)
+               {
+                 insn[1] &= 0xf0;
+                 insn[1] |= e->new_encoding;
+                 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
+                 gap = insn + posn + enctbl[e->new_encoding].bytes;
+                 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
+                 break;
+               }
  
  
-      insn = bfd_get_16 (abfd, contents + irel->r_offset + 0);
+             break;
  
  
-      addend = irel->r_addend;
-      for (i = 0; relax_reloc[i].machine; i++)
+           } /* Ends switch (reloc type) for m16c.  */
+       }
+      else /* machine == bfd_mach_m32c */
         {
         {
-#ifdef DEBUG
-         _bfd_error_handler ("insn %x %d mask %x opcode %x =%x\n",
-                             insn, i, relax_reloc[i].opcode_mask,
-                             relax_reloc[i].opcode,
-                             (insn & relax_reloc[i].opcode_mask) == relax_reloc[i].opcode);
-#endif
-         if (!(machine == relax_reloc[i].machine
-               && (insn & relax_reloc[i].opcode_mask) == relax_reloc[i].opcode
-               && (relax_reloc[i].old_reloc
-                   == (int) ELF32_R_TYPE(irel->r_info))))
-           continue;
+         /* M32CM / M32C */
  
  
-         /* At this point we've confirmed we have a matching insn.  Now
-            ensure the operand is in range.  */
-         if (relax_reloc[i].use_pcrel)
+         switch (ELF32_R_TYPE(irel->r_info))
             {
             {
-             pc = sec->output_section->vma + sec->output_offset
-               + irel->r_offset;
-             pcrel_value = symval - pc;
-#ifndef USE_REL /* put in for learning purposes */
-             pcrel_value += addend;
-#else
-             addend = bfd_get_signed_16 (abfd, contents + irel->r_offset + 2);
-             pcrel_value += addend;
-#endif
-           }
-         else
-           pcrel_value = symval;
  
  
-         if (pcrel_value >= relax_reloc[i].relax_backward
-             && pcrel_value < relax_reloc[i].relax_forward + 2)
-           {
-             /* We can relax to a shorter operand.  */
-             insn = (insn & relax_reloc[i].mask) | relax_reloc[i].new_opcode;
+           case R_M32C_RL_JUMP:
+             switch (insn[0])
+               {
+               case 0xbb: /* jmp.b */
+                 if (pcrel >= 2 && pcrel <= 9)
+                   {
+                     int p = pcrel - 2;
+                     /* Relax JMP.B -> JMP.S.  We need to get rid of
+                        the following reloc though. */
+                     insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1);
+                     new_type = R_M32C_NONE;
+                     irel->r_addend = 0x10;
+                     gap_size = 1;
+                     gap = insn + 1;
+                   }
+                 break;
+
+               case 0xce: /* jmp.w */
+                 if (pcrel <= 128 && pcrel >= -128)
+                   {
+                     /* Relax JMP.W -> JMP.B */
+                     insn[0] = 0xbb;
+                     insn[1] = 0;
+                     new_type = R_M32C_8_PCREL;
+                     gap_size = 1;
+                     gap = insn + 2;
+                   }
+                 break;
+
+               case 0xcc: /* jmp.a */
+                 if (pcrel <= 32768 && pcrel >= -32768)
+                   {
+                     /* Relax JMP.A -> JMP.W */
+                     insn[0] = 0xce;
+                     insn[1] = 0;
+                     insn[2] = 0;
+                     new_type = R_M32C_16_PCREL;
+                     gap_size = 1;
+                     gap = insn + 3;
+                   }
+                 break;
+
+               case 0xcd: /* jsr.a */
+                 if (pcrel <= 32768 && pcrel >= -32768)
+                   {
+                     /* Relax JSR.A -> JSR.W */
+                     insn[0] = 0xcf;
+                     insn[1] = 0;
+                     insn[2] = 0;
+                     new_type = R_M32C_16_PCREL;
+                     gap_size = 1;
+                     gap = insn + 3;
+                   }
+                 break;
+               }
+             break;
  
  
-             to_delete = relax_reloc[i].delete_n;
+           case R_M32C_RL_2ADDR:
+             /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
  
  
-             /* Rewrite the insn.  */
-             bfd_put_16 (abfd, insn, contents + irel->r_offset);
+             einsn = insn;
+             posn = 2;
+             if (einsn[0] == 1)
+               {
+                 /* prefix; remove it as far as the RL reloc is concerned.  */
+                 einsn ++;
+                 posn ++;
+               }
  
  
-             /* Set the new reloc type.  */
-             irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
-                                          relax_reloc[i].new_reloc);
-             irel->r_addend = pcrel_value;
-           }
-         else
-           continue;
+             enctbl = m32c_addr_encodings;
+             enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4);
+             e = & enctbl[enc];
  
  
-#ifdef DEBUG
-         _bfd_error_handler  ("insn %x pc %x index %d mask %x shift %d delete %d\n"
-                              "old reloc %s new reloc %s",
-                              insn, sec->output_section->vma
-                              + sec->output_offset + irel->r_offset + 2,
-                              i, relax_reloc[i].opcode_mask,
-                              relax_reloc[i].value_shift, to_delete,
-                              m32c_get_reloc (relax_reloc[i].old_reloc),
-                              m32c_get_reloc (relax_reloc[i].new_reloc));
-#endif
+             if (srel->r_offset == irel->r_offset + posn
+                 && e->new_encoding != enc
+                 && symval <= e->max_disp)
+               {
+                 einsn[0] &= 0x8f;
+                 einsn[0] |= (e->new_encoding & 0x1c) << 2;
+                 einsn[1] &= 0xcf;
+                 einsn[1] |= (e->new_encoding & 0x03) << 4;
+                 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
+                 gap = insn + posn + enctbl[e->new_encoding].bytes;
+                 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
+                 break;
+               }
+             if (relax_relocs == 2)
+                 srel ++;
+             posn += e->bytes;
+
+             goto try_1addr_32;
+
+           case R_M32C_RL_1ADDR:
+             /* xxxx DDDx DDxx xxxx [disp] */
+
+             einsn = insn;
+             posn = 2;
+             if (einsn[0] == 1)
+               {
+                 /* prefix; remove it as far as the RL reloc is concerned.  */
+                 einsn ++;
+                 posn ++;
+               }
+
+             enctbl = m32c_addr_encodings;
+
+           try_1addr_32:
+             /* srel, posn, and enc must be set here.  */
+
+             symval = OFFSET_FOR_RELOC (srel);
+             enc = ((einsn[0] & 0x0e) << 1) |  ((einsn[1] & 0xc0) >> 6);
+             e = & enctbl[enc];
+
+             if (srel->r_offset == irel->r_offset + posn
+                 && e->new_encoding != enc
+                 && symval <= e->max_disp)
+               {
+                 einsn[0] &= 0xf1;
+                 einsn[0] |= (e->new_encoding & 0x1c) >> 1;
+                 einsn[1] &= 0x3f;
+                 einsn[1] |= (e->new_encoding & 0x03) << 6;
+                 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
+                 gap = insn + posn + enctbl[e->new_encoding].bytes;
+                 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
+                 break;
+               }
+
+             break;
+
+           } /* Ends switch (reloc type) for m32c.  */
+       }
+
+      if (gap_size == 0)
+       continue;
+
+      *again = TRUE;
+
+      srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type);
+
+      /* Note that we've changed the relocs, section contents, etc.  */
+      elf_section_data (sec)->relocs = internal_relocs;
+      free_relocs = NULL;
+
+      elf_section_data (sec)->this_hdr.contents = contents;
+      free_contents = NULL;
  
  
-         /* Note that we've changed the relocs, section contents, etc.  */
-         elf_section_data (sec)->relocs = internal_relocs;
-         free_relocs = NULL;
+      symtab_hdr->contents = (bfd_byte *) intsyms;
+      free_intsyms = NULL;
  
  
-         elf_section_data (sec)->this_hdr.contents = contents;
-         free_contents = NULL;
+      bytes_saved += gap_size;
  
  
-         symtab_hdr->contents = (bfd_byte *) extsyms;
-         free_extsyms = NULL;
+      if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size))
+       goto error_return;
  
  
-         /* Delete TO_DELETE bytes of data.  */
-         if (! m32c_elf_relax_delete_bytes
-             (abfd, sec, irel->r_offset + relax_reloc[i].value_shift,
-              to_delete))
-           goto error_return;
-       } /* next relax_reloc */
      } /* next relocation */
  
    if (free_relocs != NULL)
      } /* next relocation */
  
    if (free_relocs != NULL)
@@ -1500,18 +1921,18 @@ m32c_elf_relax_section
        free (shndx_buf);
      }
  
        free (shndx_buf);
      }
  
-  if (free_extsyms != NULL)
+  if (free_intsyms != NULL)
      {
        if (! link_info->keep_memory)
      {
        if (! link_info->keep_memory)
-       free (free_extsyms);
+       free (free_intsyms);
        /* Cache the symbols for elf_link_input_bfd.  */
        else
        /* Cache the symbols for elf_link_input_bfd.  */
        else
-       symtab_hdr->contents = NULL /* (unsigned char *) extsyms*/;
+       {
+       symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/;
+       }
  
  
-      free_extsyms = NULL;
+      free_intsyms = NULL;
      }
      }
-  /* elf_link_input_bfd expects internal syms.  */
-  symtab_hdr->contents = NULL;
  
    return TRUE;
  
  
    return TRUE;
  
@@ -1525,8 +1946,8 @@ m32c_elf_relax_section
        shndx_hdr->contents = NULL;
        free (shndx_buf);
      }
        shndx_hdr->contents = NULL;
        free (shndx_buf);
      }
-  if (free_extsyms != NULL)
-    free (free_extsyms);
+  if (free_intsyms != NULL)
+    free (free_intsyms);
    return FALSE;
  }
  
    return FALSE;
  }
  
@@ -1534,10 +1955,10 @@ m32c_elf_relax_section
  
  static bfd_boolean
  m32c_elf_relax_delete_bytes
  
  static bfd_boolean
  m32c_elf_relax_delete_bytes
- (bfd *      abfd,
+ (bfd *             abfd,
    asection * sec,
    bfd_vma    addr,
    asection * sec,
    bfd_vma    addr,
-  int        count)
+  int       count)
  {
    Elf_Internal_Shdr *symtab_hdr;
    Elf_Internal_Shdr *shndx_hdr;
  {
    Elf_Internal_Shdr *symtab_hdr;
    Elf_Internal_Shdr *shndx_hdr;
@@ -1545,27 +1966,18 @@ m32c_elf_relax_delete_bytes
    bfd_byte *contents;
    Elf_Internal_Rela *irel;
    Elf_Internal_Rela *irelend;
    bfd_byte *contents;
    Elf_Internal_Rela *irel;
    Elf_Internal_Rela *irelend;
-  Elf_Internal_Rela *irelalign;
    bfd_vma toaddr;
    bfd_vma toaddr;
-  Elf32_External_Sym *esym;
-  Elf32_External_Sym *esymend;
-  Elf32_External_Sym *extsyms;
+  Elf_Internal_Sym *isym;
+  Elf_Internal_Sym *isymend;
+  Elf_Internal_Sym *intsyms;
    Elf_External_Sym_Shndx *shndx_buf;
    Elf_External_Sym_Shndx *shndx;
    struct elf_link_hash_entry ** sym_hashes;
    struct elf_link_hash_entry ** end_hashes;
    Elf_External_Sym_Shndx *shndx_buf;
    Elf_External_Sym_Shndx *shndx;
    struct elf_link_hash_entry ** sym_hashes;
    struct elf_link_hash_entry ** end_hashes;
-  unsigned int                  symcount;
- 
-  symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
-  extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
-  shndx_hdr  = & elf_tdata (abfd)->symtab_shndx_hdr;
-  shndx_buf  = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
-  sec_shndx  = _bfd_elf_section_from_bfd_section (abfd, sec);
+  unsigned int                 symcount;
+
    contents   = elf_section_data (sec)->this_hdr.contents;
  
    contents   = elf_section_data (sec)->this_hdr.contents;
  
-  /* The deletion must stop at the next ALIGN reloc for an aligment
-     power larger than the number of bytes we are deleting.  */
-  irelalign = NULL;
    toaddr = sec->size;
  
    irel = elf_section_data (sec)->relocs;
    toaddr = sec->size;
  
    irel = elf_section_data (sec)->relocs;
@@ -1581,27 +1993,81 @@ m32c_elf_relax_delete_bytes
        /* Get the new reloc address.  */
        if (irel->r_offset > addr && irel->r_offset < toaddr)
         irel->r_offset -= count;
        /* Get the new reloc address.  */
        if (irel->r_offset > addr && irel->r_offset < toaddr)
         irel->r_offset -= count;
-      if (irel->r_addend > addr && irel->r_addend < toaddr)
-       irel->r_addend -= count;
+
+      if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP
+         && irel->r_addend == 0x10 /* one byte insn, no relocs */
+         && irel->r_offset + 1 < addr
+         && irel->r_offset + 7 > addr)
+       {
+         bfd_vma disp;
+         unsigned char *insn = &contents[irel->r_offset];
+         disp = *insn;
+         /* This is a JMP.S, which we have to manually update. */
+         if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
+           {
+             if ((*insn & 0xf8) != 0x60)
+               continue;
+             disp = (disp & 7);
+           }
+         else
+           {
+             if ((*insn & 0xce) != 0x4a)
+               continue;
+             disp = ((disp & 0x30) >> 3) | (disp & 1);
+           }
+         if (irel->r_offset + disp + 2 >= addr+count)
+           {
+             disp -= count;
+             if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
+               {
+                 *insn = (*insn & 0xf8) | disp;
+               }
+             else
+               {
+                 *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1);
+               }
+           }
+       }
      }
  
    /* Adjust the local symbols defined in this section.  */
      }
  
    /* Adjust the local symbols defined in this section.  */
-  shndx = shndx_buf;
-  esym = extsyms;
-  esymend = esym + symtab_hdr->sh_info;
-  for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL))
-    {
-      Elf_Internal_Sym isym;
-      Elf_External_Sym_Shndx dummy;
+  symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
+  intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
+  isym = intsyms;
+  isymend = isym + symtab_hdr->sh_info;
  
  
-      bfd_elf32_swap_symbol_in (abfd, esym, shndx, &isym);
+  sec_shndx  = _bfd_elf_section_from_bfd_section (abfd, sec);
+  if (elf_symtab_shndx_list (abfd))
+    {
+      shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
+      shndx_buf  = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
+    }
+  else
+    {
+      shndx_hdr = NULL;
+      shndx_buf = NULL;
+    }
+  shndx = shndx_buf;
  
  
-      if ((int) isym.st_shndx == sec_shndx
-         && isym.st_value > addr
-         && isym.st_value < toaddr)
+  for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL))
+    {
+      /* If the symbol is in the range of memory we just moved, we
+        have to adjust its value.  */
+      if ((int) isym->st_shndx == sec_shndx
+         && isym->st_value > addr
+         && isym->st_value < toaddr)
         {
         {
-         isym.st_value -= count;
-         bfd_elf32_swap_symbol_out (abfd, &isym, (PTR) esym, (PTR) & dummy);
+         isym->st_value -= count;
+       }
+      /* If the symbol *spans* the bytes we just deleted (i.e. it's
+        *end* is in the moved bytes but it's *start* isn't), then we
+        must adjust its size.  */
+      if ((int) isym->st_shndx == sec_shndx
+           && isym->st_value < addr
+         && isym->st_value + isym->st_size > addr
+         && isym->st_value + isym->st_size < toaddr)
+       {
+         isym->st_size -= count;
         }
      }
  
         }
      }
  
@@ -1617,27 +2083,49 @@ m32c_elf_relax_delete_bytes
        struct elf_link_hash_entry * sym_hash = * sym_hashes;
  
        if (sym_hash &&
        struct elf_link_hash_entry * sym_hash = * sym_hashes;
  
        if (sym_hash &&
-         (   sym_hash->root.type == bfd_link_hash_defined
+         (sym_hash->root.type == bfd_link_hash_defined
            || sym_hash->root.type == bfd_link_hash_defweak)
            || sym_hash->root.type == bfd_link_hash_defweak)
-         && sym_hash->root.u.def.section == sec
-         && sym_hash->root.u.def.value > addr
-         && sym_hash->root.u.def.value < toaddr)
-       sym_hash->root.u.def.value -= count;
+         && sym_hash->root.u.def.section == sec)
+       {
+         if (sym_hash->root.u.def.value > addr
+             && sym_hash->root.u.def.value < toaddr)
+           {
+             sym_hash->root.u.def.value -= count;
+           }
+         if (sym_hash->root.u.def.value < addr
+             && sym_hash->root.u.def.value + sym_hash->size > addr
+             && sym_hash->root.u.def.value + sym_hash->size < toaddr)
+           {
+             sym_hash->size -= count;
+           }
+       }
      }
  
    return TRUE;
  }
      }
  
    return TRUE;
  }
+\f
+/* This is for versions of gcc prior to 4.3.  */
+static unsigned int
+_bfd_m32c_elf_eh_frame_address_size (bfd *abfd,
+                                    const asection *sec ATTRIBUTE_UNUSED)
+{
+  if ((elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK) == EF_M32C_CPU_M16C)
+    return 2;
+  return 4;
+}
+
  \f
  
  #define ELF_ARCH               bfd_arch_m32c
  #define ELF_MACHINE_CODE       EM_M32C
  \f
  
  #define ELF_ARCH               bfd_arch_m32c
  #define ELF_MACHINE_CODE       EM_M32C
-#define ELF_MAXPAGESIZE                0x1000
+#define ELF_MACHINE_ALT1       EM_M32C_OLD
+#define ELF_MAXPAGESIZE                0x100
  
  #if 0
  
  #if 0
-#define TARGET_BIG_SYM         bfd_elf32_m32c_vec
+#define TARGET_BIG_SYM         m32c_elf32_vec
  #define TARGET_BIG_NAME                "elf32-m32c"
  #else
  #define TARGET_BIG_NAME                "elf32-m32c"
  #else
-#define TARGET_LITTLE_SYM              bfd_elf32_m32c_vec
+#define TARGET_LITTLE_SYM              m32c_elf32_vec
  #define TARGET_LITTLE_NAME             "elf32-m32c"
  #endif
  
  #define TARGET_LITTLE_NAME             "elf32-m32c"
  #endif
  
@@ -1645,19 +2133,19 @@ m32c_elf_relax_delete_bytes
  #define elf_info_to_howto                      m32c_info_to_howto_rela
  #define elf_backend_object_p                   m32c_elf_object_p
  #define elf_backend_relocate_section           m32c_elf_relocate_section
  #define elf_info_to_howto                      m32c_info_to_howto_rela
  #define elf_backend_object_p                   m32c_elf_object_p
  #define elf_backend_relocate_section           m32c_elf_relocate_section
-#define elf_backend_gc_mark_hook               m32c_elf_gc_mark_hook
-#define elf_backend_gc_sweep_hook              m32c_elf_gc_sweep_hook
-#define elf_backend_check_relocs                m32c_elf_check_relocs
+#define elf_backend_check_relocs               m32c_elf_check_relocs
  #define elf_backend_object_p                   m32c_elf_object_p
  #define elf_backend_object_p                   m32c_elf_object_p
-#define elf_symbol_leading_char                 ('_')
+#define elf_symbol_leading_char                        ('_')
  #define elf_backend_always_size_sections \
    m32c_elf_always_size_sections
  #define elf_backend_finish_dynamic_sections \
    m32c_elf_finish_dynamic_sections
  
  #define elf_backend_can_gc_sections            1
  #define elf_backend_always_size_sections \
    m32c_elf_always_size_sections
  #define elf_backend_finish_dynamic_sections \
    m32c_elf_finish_dynamic_sections
  
  #define elf_backend_can_gc_sections            1
+#define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
  
  #define bfd_elf32_bfd_reloc_type_lookup                m32c_reloc_type_lookup
  
  #define bfd_elf32_bfd_reloc_type_lookup                m32c_reloc_type_lookup
+#define bfd_elf32_bfd_reloc_name_lookup        m32c_reloc_name_lookup
  #define bfd_elf32_bfd_relax_section            m32c_elf_relax_section
  #define bfd_elf32_bfd_set_private_flags                m32c_elf_set_private_flags
  #define bfd_elf32_bfd_merge_private_bfd_data   m32c_elf_merge_private_bfd_data
  #define bfd_elf32_bfd_relax_section            m32c_elf_relax_section
  #define bfd_elf32_bfd_set_private_flags                m32c_elf_set_private_flags
  #define bfd_elf32_bfd_merge_private_bfd_data   m32c_elf_merge_private_bfd_data