bfd/elf32-m32c.c

   1 /* M16C/M32C specific support for 32-bit ELF.
   2    Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/m32c.h"
  26 #include "libiberty.h"
  27
  28 /* Forward declarations.  */
  29 static reloc_howto_type * m32c_reloc_type_lookup
  30   (bfd *, bfd_reloc_code_real_type);
  31 static void m32c_info_to_howto_rela
  32   (bfd *, arelent *, Elf_Internal_Rela *);
  33 static bfd_boolean m32c_elf_relocate_section
  34   (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
  35 static bfd_boolean m32c_elf_check_relocs
  36   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
  37 static bfd_boolean m32c_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int);
  38 #ifdef DEBUG
  39 char * m32c_get_reloc (long reloc);
  40 void dump_symtab (bfd *, void *, void *);
  41 #endif
  42 static bfd_boolean m32c_elf_relax_section
  43 (bfd *abfd, asection *sec, struct bfd_link_info *link_info, bfd_boolean *again);
  44
  45
  46 static reloc_howto_type m32c_elf_howto_table [] =
  47 {
  48   /* This reloc does nothing.  */
  49   HOWTO (R_M32C_NONE,           /* type */
  50          0,                     /* rightshift */
  51          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  52          32,                    /* bitsize */
  53          FALSE,                 /* pc_relative */
  54          0,                     /* bitpos */
  55          complain_overflow_bitfield, /* complain_on_overflow */
  56          bfd_elf_generic_reloc, /* special_function */
  57          "R_M32C_NONE",         /* name */
  58          FALSE,                 /* partial_inplace */
  59          0,                     /* src_mask */
  60          0,                     /* dst_mask */
  61          FALSE),                /* pcrel_offset */
  62
  63   /* GCC intentionally overflows these next two in order to work
  64      around limitations in the addressing modes, so don't complain
  65      about overflow.  */
  66   HOWTO (R_M32C_16,             /* type */
  67          0,                     /* rightshift */
  68          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  69          16,                    /* bitsize */
  70          FALSE,                 /* pc_relative */
  71          0,                     /* bitpos */
  72          complain_overflow_dont, /* complain_on_overflow */
  73          bfd_elf_generic_reloc, /* special_function */
  74          "R_M32C_16",           /* name */
  75          FALSE,                 /* partial_inplace */
  76          0,                     /* src_mask */
  77          0xffff,                /* dst_mask */
  78          FALSE),                /* pcrel_offset */
  79
  80   HOWTO (R_M32C_24,             /* type */
  81          0,                     /* rightshift */
  82          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  83          24,                    /* bitsize */
  84          FALSE,                 /* pc_relative */
  85          0,                     /* bitpos */
  86          complain_overflow_dont, /* complain_on_overflow */
  87          bfd_elf_generic_reloc, /* special_function */
  88          "R_M32C_24",           /* name */
  89          FALSE,                 /* partial_inplace */
  90          0,                     /* src_mask */
  91          0xffffff,              /* dst_mask */
  92          FALSE),                /* pcrel_offset */
  93
  94   HOWTO (R_M32C_32,             /* type */
  95          0,                     /* rightshift */
  96          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  97          32,                    /* bitsize */
  98          FALSE,                 /* pc_relative */
  99          0,                     /* bitpos */
 100          complain_overflow_bitfield, /* complain_on_overflow */
 101          bfd_elf_generic_reloc, /* special_function */
 102          "R_M32C_32",           /* name */
 103          FALSE,                 /* partial_inplace */
 104          0,                     /* src_mask */
 105          0xffffffff,            /* dst_mask */
 106          FALSE),                /* pcrel_offset */
 107
 108   HOWTO (R_M32C_8_PCREL,        /* type */
 109          0,                     /* rightshift */
 110          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 111          8,                     /* bitsize */
 112          TRUE,                  /* pc_relative */
 113          0,                     /* bitpos */
 114          complain_overflow_signed, /* complain_on_overflow */
 115          bfd_elf_generic_reloc, /* special_function */
 116          "R_M32C_8_PCREL",      /* name */
 117          FALSE,                 /* partial_inplace */
 118          0,                     /* src_mask */
 119          0xff,                  /* dst_mask */
 120          TRUE),                 /* pcrel_offset */
 121
 122   HOWTO (R_M32C_16_PCREL,       /* type */
 123          0,                     /* rightshift */
 124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 125          16,                    /* bitsize */
 126          TRUE,                  /* pc_relative */
 127          0,                     /* bitpos */
 128          complain_overflow_signed, /* complain_on_overflow */
 129          bfd_elf_generic_reloc, /* special_function */
 130          "R_M32C_16_PCREL",     /* name */
 131          FALSE,                 /* partial_inplace */
 132          0,                     /* src_mask */
 133          0xffff,                /* dst_mask */
 134          TRUE),                 /* pcrel_offset */
 135
 136   HOWTO (R_M32C_8,              /* type */
 137          0,                     /* rightshift */
 138          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 139          8,                     /* bitsize */
 140          FALSE,                 /* pc_relative */
 141          0,                     /* bitpos */
 142          complain_overflow_unsigned, /* complain_on_overflow */
 143          bfd_elf_generic_reloc, /* special_function */
 144          "R_M32C_8",            /* name */
 145          FALSE,                 /* partial_inplace */
 146          0,                     /* src_mask */
 147          0xff,                  /* dst_mask */
 148          FALSE),                /* pcrel_offset */
 149
 150   HOWTO (R_M32C_LO16,           /* type */
 151          0,                     /* rightshift */
 152          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 153          16,                    /* bitsize */
 154          FALSE,                 /* pc_relative */
 155          0,                     /* bitpos */
 156          complain_overflow_dont, /* complain_on_overflow */
 157          bfd_elf_generic_reloc, /* special_function */
 158          "R_M32C_LO16",         /* name */
 159          FALSE,                 /* partial_inplace */
 160          0,                     /* src_mask */
 161          0xffff,                /* dst_mask */
 162          FALSE),                /* pcrel_offset */
 163
 164   HOWTO (R_M32C_HI8,            /* type */
 165          0,                     /* rightshift */
 166          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 167          8,                     /* bitsize */
 168          FALSE,                 /* pc_relative */
 169          0,                     /* bitpos */
 170          complain_overflow_dont, /* complain_on_overflow */
 171          bfd_elf_generic_reloc, /* special_function */
 172          "R_M32C_HI8",          /* name */
 173          FALSE,                 /* partial_inplace */
 174          0,                     /* src_mask */
 175          0xff,                  /* dst_mask */
 176          FALSE),                /* pcrel_offset */
 177
 178   HOWTO (R_M32C_HI16,           /* type */
 179          0,                     /* rightshift */
 180          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 181          16,                    /* bitsize */
 182          FALSE,                 /* pc_relative */
 183          0,                     /* bitpos */
 184          complain_overflow_dont, /* complain_on_overflow */
 185          bfd_elf_generic_reloc, /* special_function */
 186          "R_M32C_HI16",         /* name */
 187          FALSE,                 /* partial_inplace */
 188          0,                     /* src_mask */
 189          0xffff,                /* dst_mask */
 190          FALSE),                /* pcrel_offset */
 191
 192   HOWTO (R_M32C_RL_JUMP,        /* type */
 193          0,                     /* rightshift */
 194          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 195          0,                     /* bitsize */
 196          FALSE,                 /* pc_relative */
 197          0,                     /* bitpos */
 198          complain_overflow_signed, /* complain_on_overflow */
 199          bfd_elf_generic_reloc, /* special_function */
 200          "R_M32C_RL_JUMP",      /* name */
 201          FALSE,                 /* partial_inplace */
 202          0,                     /* src_mask */
 203          0,                     /* dst_mask */
 204          FALSE),                /* pcrel_offset */
 205
 206   HOWTO (R_M32C_RL_1ADDR,       /* type */
 207          0,                     /* rightshift */
 208          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 209          0,                     /* bitsize */
 210          FALSE,                 /* pc_relative */
 211          0,                     /* bitpos */
 212          complain_overflow_signed, /* complain_on_overflow */
 213          bfd_elf_generic_reloc, /* special_function */
 214          "R_M32C_RL_1ADDR",     /* name */
 215          FALSE,                 /* partial_inplace */
 216          0,                     /* src_mask */
 217          0,                     /* dst_mask */
 218          FALSE),                /* pcrel_offset */
 219
 220   HOWTO (R_M32C_RL_2ADDR,       /* type */
 221          0,                     /* rightshift */
 222          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 223          0,                     /* bitsize */
 224          FALSE,                 /* pc_relative */
 225          0,                     /* bitpos */
 226          complain_overflow_signed, /* complain_on_overflow */
 227          bfd_elf_generic_reloc, /* special_function */
 228          "R_M32C_RL_2ADDR",     /* name */
 229          FALSE,                 /* partial_inplace */
 230          0,                     /* src_mask */
 231          0,                     /* dst_mask */
 232          FALSE),                /* pcrel_offset */
 233
 234 };
 235 \f
 236 /* Map BFD reloc types to M32C ELF reloc types.  */
 237
 238 struct m32c_reloc_map
 239 {
 240   bfd_reloc_code_real_type bfd_reloc_val;
 241   unsigned int m32c_reloc_val;
 242 };
 243
 244 static const struct m32c_reloc_map m32c_reloc_map [] =
 245 {
 246   { BFD_RELOC_NONE,             R_M32C_NONE },
 247   { BFD_RELOC_16,               R_M32C_16 },
 248   { BFD_RELOC_24,               R_M32C_24 },
 249   { BFD_RELOC_32,               R_M32C_32 },
 250   { BFD_RELOC_8_PCREL,          R_M32C_8_PCREL },
 251   { BFD_RELOC_16_PCREL,         R_M32C_16_PCREL },
 252   { BFD_RELOC_8,                R_M32C_8 },
 253   { BFD_RELOC_LO16,             R_M32C_LO16 },
 254   { BFD_RELOC_HI16,             R_M32C_HI16 },
 255   { BFD_RELOC_M32C_HI8,         R_M32C_HI8 },
 256   { BFD_RELOC_M32C_RL_JUMP,     R_M32C_RL_JUMP },
 257   { BFD_RELOC_M32C_RL_1ADDR,    R_M32C_RL_1ADDR },
 258   { BFD_RELOC_M32C_RL_2ADDR,    R_M32C_RL_2ADDR }
 259 };
 260
 261 static reloc_howto_type *
 262 m32c_reloc_type_lookup
 263     (bfd *                    abfd ATTRIBUTE_UNUSED,
 264      bfd_reloc_code_real_type code)
 265 {
 266   unsigned int i;
 267
 268   for (i = ARRAY_SIZE (m32c_reloc_map); --i;)
 269     if (m32c_reloc_map [i].bfd_reloc_val == code)
 270       return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val];
 271
 272   return NULL;
 273 }
 274
 275 static reloc_howto_type *
 276 m32c_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
 277 {
 278   unsigned int i;
 279
 280   for (i = 0;
 281        i < sizeof (m32c_elf_howto_table) / sizeof (m32c_elf_howto_table[0]);
 282        i++)
 283     if (m32c_elf_howto_table[i].name != NULL
 284         && strcasecmp (m32c_elf_howto_table[i].name, r_name) == 0)
 285       return &m32c_elf_howto_table[i];
 286
 287   return NULL;
 288 }
 289
 290 /* Set the howto pointer for an M32C ELF reloc.  */
 291
 292 static void
 293 m32c_info_to_howto_rela
 294     (bfd *               abfd ATTRIBUTE_UNUSED,
 295      arelent *           cache_ptr,
 296      Elf_Internal_Rela * dst)
 297 {
 298   unsigned int r_type;
 299
 300   r_type = ELF32_R_TYPE (dst->r_info);
 301   BFD_ASSERT (r_type < (unsigned int) R_M32C_max);
 302   cache_ptr->howto = & m32c_elf_howto_table [r_type];
 303 }
 304
 305 \f
 306
 307 /* Relocate an M32C ELF section.
 308    There is some attempt to make this function usable for many architectures,
 309    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 310    if only to serve as a learning tool.
 311
 312    The RELOCATE_SECTION function is called by the new ELF backend linker
 313    to handle the relocations for a section.
 314
 315    The relocs are always passed as Rela structures; if the section
 316    actually uses Rel structures, the r_addend field will always be
 317    zero.
 318
 319    This function is responsible for adjusting the section contents as
 320    necessary, and (if using Rela relocs and generating a relocatable
 321    output file) adjusting the reloc addend as necessary.
 322
 323    This function does not have to worry about setting the reloc
 324    address or the reloc symbol index.
 325
 326    LOCAL_SYMS is a pointer to the swapped in local symbols.
 327
 328    LOCAL_SECTIONS is an array giving the section in the input file
 329    corresponding to the st_shndx field of each local symbol.
 330
 331    The global hash table entry for the global symbols can be found
 332    via elf_sym_hashes (input_bfd).
 333
 334    When generating relocatable output, this function must handle
 335    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 336    going to be the section symbol corresponding to the output
 337    section, which means that the addend must be adjusted
 338    accordingly.  */
 339
 340 static bfd_boolean
 341 m32c_elf_relocate_section
 342     (bfd *                   output_bfd ATTRIBUTE_UNUSED,
 343      struct bfd_link_info *  info,
 344      bfd *                   input_bfd,
 345      asection *              input_section,
 346      bfd_byte *              contents,
 347      Elf_Internal_Rela *     relocs,
 348      Elf_Internal_Sym *      local_syms,
 349      asection **             local_sections)
 350 {
 351   Elf_Internal_Shdr *           symtab_hdr;
 352   struct elf_link_hash_entry ** sym_hashes;
 353   Elf_Internal_Rela *           rel;
 354   Elf_Internal_Rela *           relend;
 355   bfd *dynobj;
 356   asection *splt;
 357
 358   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 359   sym_hashes = elf_sym_hashes (input_bfd);
 360   relend     = relocs + input_section->reloc_count;
 361
 362   dynobj = elf_hash_table (info)->dynobj;
 363   splt = NULL;
 364   if (dynobj != NULL)
 365     splt = bfd_get_section_by_name (dynobj, ".plt");
 366
 367   for (rel = relocs; rel < relend; rel ++)
 368     {
 369       reloc_howto_type *           howto;
 370       unsigned long                r_symndx;
 371       Elf_Internal_Sym *           sym;
 372       asection *                   sec;
 373       struct elf_link_hash_entry * h;
 374       bfd_vma                      relocation;
 375       bfd_reloc_status_type        r;
 376       const char *                 name = NULL;
 377       int                          r_type;
 378
 379       r_type = ELF32_R_TYPE (rel->r_info);
 380
 381       /* These are only used for relaxing; we don't actually relocate
 382          anything with them, so skip them.  */
 383       if (r_type == R_M32C_RL_JUMP
 384           || r_type == R_M32C_RL_1ADDR
 385           || r_type == R_M32C_RL_2ADDR)
 386         continue;
 387
 388       r_symndx = ELF32_R_SYM (rel->r_info);
 389
 390       howto  = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 391       h      = NULL;
 392       sym    = NULL;
 393       sec    = NULL;
 394       relocation = 0;
 395
 396       if (r_symndx < symtab_hdr->sh_info)
 397         {
 398           sym = local_syms + r_symndx;
 399           sec = local_sections [r_symndx];
 400           relocation = (sec->output_section->vma
 401                         + sec->output_offset
 402                         + sym->st_value);
 403
 404           name = bfd_elf_string_from_elf_section
 405             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 406           name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
 407         }
 408       else
 409         {
 410           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
 411
 412           while (h->root.type == bfd_link_hash_indirect
 413                  || h->root.type == bfd_link_hash_warning)
 414             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 415
 416           name = h->root.root.string;
 417
 418           if (h->root.type == bfd_link_hash_defined
 419               || h->root.type == bfd_link_hash_defweak)
 420             {
 421               sec = h->root.u.def.section;
 422               relocation = (h->root.u.def.value
 423                             + sec->output_section->vma
 424                             + sec->output_offset);
 425             }
 426           else if (h->root.type == bfd_link_hash_undefweak)
 427             ;
 428           else if (!info->relocatable)
 429             {
 430               if (! ((*info->callbacks->undefined_symbol)
 431                      (info, h->root.root.string, input_bfd,
 432                       input_section, rel->r_offset, TRUE)))
 433                 return FALSE;
 434             }
 435         }
 436
 437       if (sec != NULL && elf_discarded_section (sec))
 438         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 439                                          rel, relend, howto, contents);
 440
 441       if (info->relocatable)
 442         {
 443           /* This is a relocatable link.  We don't have to change
 444              anything, unless the reloc is against a section symbol,
 445              in which case we have to adjust according to where the
 446              section symbol winds up in the output section.  */
 447           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 448             rel->r_addend += sec->output_offset;
 449           continue;
 450         }
 451
 452       switch (ELF32_R_TYPE (rel->r_info))
 453         {
 454         case R_M32C_16:
 455           {
 456             bfd_vma *plt_offset;
 457
 458             if (h != NULL)
 459               plt_offset = &h->plt.offset;
 460             else
 461               plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
 462
 463             /*      printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
 464                     relocation, *plt_offset);*/
 465             if (relocation <= 0xffff)
 466               {
 467                 /* If the symbol is in range for a 16-bit address, we should
 468                    have deallocated the plt entry in relax_section.  */
 469                 BFD_ASSERT (*plt_offset == (bfd_vma) -1);
 470               }
 471             else
 472               {
 473                 /* If the symbol is out of range for a 16-bit address,
 474                    we must have allocated a plt entry.  */
 475                 BFD_ASSERT (*plt_offset != (bfd_vma) -1);
 476
 477                 /* If this is the first time we've processed this symbol,
 478                    fill in the plt entry with the correct symbol address.  */
 479                 if ((*plt_offset & 1) == 0)
 480                   {
 481                     unsigned int x;
 482
 483                     x = 0x000000fc;  /* jmpf */
 484                     x |= (relocation << 8) & 0xffffff00;
 485                     bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
 486                     *plt_offset |= 1;
 487                   }
 488
 489                 relocation = (splt->output_section->vma
 490                               + splt->output_offset
 491                               + (*plt_offset & -2));
 492                 if (name)
 493                 {
 494                   char *newname = bfd_malloc (strlen(name)+5);
 495                   strcpy (newname, name);
 496                   strcat(newname, ".plt");
 497                   _bfd_generic_link_add_one_symbol (info,
 498                                                     input_bfd,
 499                                                     newname,
 500                                                     BSF_FUNCTION | BSF_WEAK,
 501                                                     splt,
 502                                                     (*plt_offset & -2),
 503                                                     0,
 504                                                     1,
 505                                                     0,
 506                                                     0);
 507                 }
 508               }
 509           }
 510           break;
 511
 512         case R_M32C_HI8:
 513         case R_M32C_HI16:
 514           relocation >>= 16;
 515           break;
 516         }
 517
 518 #if 0
 519       printf ("relocate %s at %06lx relocation %06lx addend %ld  ",
 520               m32c_elf_howto_table[ELF32_R_TYPE(rel->r_info)].name,
 521               rel->r_offset + input_section->output_section->vma + input_section->output_offset,
 522               relocation, rel->r_addend);
 523       {
 524         int i;
 525         for (i=0; i<4; i++)
 526           printf (" %02x", contents[rel->r_offset+i]);
 527         printf ("\n");
 528       }
 529 #endif
 530       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 531                                     contents, rel->r_offset, relocation,
 532                                     rel->r_addend);
 533
 534       if (r != bfd_reloc_ok)
 535         {
 536           const char * msg = (const char *) NULL;
 537
 538           switch (r)
 539             {
 540             case bfd_reloc_overflow:
 541               r = info->callbacks->reloc_overflow
 542                 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
 543                  input_bfd, input_section, rel->r_offset);
 544               break;
 545
 546             case bfd_reloc_undefined:
 547               r = info->callbacks->undefined_symbol
 548                 (info, name, input_bfd, input_section, rel->r_offset,
 549                  TRUE);
 550               break;
 551
 552             case bfd_reloc_outofrange:
 553               msg = _("internal error: out of range error");
 554               break;
 555
 556             case bfd_reloc_notsupported:
 557               msg = _("internal error: unsupported relocation error");
 558               break;
 559
 560             case bfd_reloc_dangerous:
 561               msg = _("internal error: dangerous relocation");
 562               break;
 563
 564             default:
 565               msg = _("internal error: unknown error");
 566               break;
 567             }
 568
 569           if (msg)
 570             r = info->callbacks->warning
 571               (info, msg, name, input_bfd, input_section, rel->r_offset);
 572
 573           if (! r)
 574             return FALSE;
 575         }
 576     }
 577
 578   return TRUE;
 579 }
 580 \f
 581 /* We support 16-bit pointers to code above 64k by generating a thunk
 582    below 64k containing a JMP instruction to the final address.  */
 583
 584 static bfd_boolean
 585 m32c_elf_check_relocs
 586     (bfd *                     abfd,
 587      struct bfd_link_info *    info,
 588      asection *                sec,
 589      const Elf_Internal_Rela * relocs)
 590 {
 591   Elf_Internal_Shdr *           symtab_hdr;
 592   struct elf_link_hash_entry ** sym_hashes;
 593   const Elf_Internal_Rela *     rel;
 594   const Elf_Internal_Rela *     rel_end;
 595   bfd_vma *local_plt_offsets;
 596   asection *splt;
 597   bfd *dynobj;
 598
 599   if (info->relocatable)
 600     return TRUE;
 601
 602   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 603   sym_hashes = elf_sym_hashes (abfd);
 604   local_plt_offsets = elf_local_got_offsets (abfd);
 605   splt = NULL;
 606   dynobj = elf_hash_table(info)->dynobj;
 607
 608   rel_end = relocs + sec->reloc_count;
 609   for (rel = relocs; rel < rel_end; rel++)
 610     {
 611       struct elf_link_hash_entry *h;
 612       unsigned long r_symndx;
 613       bfd_vma *offset;
 614
 615       r_symndx = ELF32_R_SYM (rel->r_info);
 616       if (r_symndx < symtab_hdr->sh_info)
 617         h = NULL;
 618       else
 619         {
 620           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 621           while (h->root.type == bfd_link_hash_indirect
 622                  || h->root.type == bfd_link_hash_warning)
 623             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 624         }
 625
 626       switch (ELF32_R_TYPE (rel->r_info))
 627         {
 628           /* This relocation describes a 16-bit pointer to a function.
 629              We may need to allocate a thunk in low memory; reserve memory
 630              for it now.  */
 631         case R_M32C_16:
 632           if (dynobj == NULL)
 633             elf_hash_table (info)->dynobj = dynobj = abfd;
 634           if (splt == NULL)
 635             {
 636               splt = bfd_get_section_by_name (dynobj, ".plt");
 637               if (splt == NULL)
 638                 {
 639                   flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 640                                     | SEC_IN_MEMORY | SEC_LINKER_CREATED
 641                                     | SEC_READONLY | SEC_CODE);
 642                   splt = bfd_make_section_with_flags (dynobj, ".plt", flags);
 643                   if (splt == NULL
 644                       || ! bfd_set_section_alignment (dynobj, splt, 1))
 645                     return FALSE;
 646                 }
 647             }
 648
 649           if (h != NULL)
 650             offset = &h->plt.offset;
 651           else
 652             {
 653               if (local_plt_offsets == NULL)
 654                 {
 655                   size_t size;
 656                   unsigned int i;
 657
 658                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
 659                   local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
 660                   if (local_plt_offsets == NULL)
 661                     return FALSE;
 662                   elf_local_got_offsets (abfd) = local_plt_offsets;
 663
 664                   for (i = 0; i < symtab_hdr->sh_info; i++)
 665                     local_plt_offsets[i] = (bfd_vma) -1;
 666                 }
 667               offset = &local_plt_offsets[r_symndx];
 668             }
 669
 670           if (*offset == (bfd_vma) -1)
 671             {
 672               *offset = splt->size;
 673               splt->size += 4;
 674             }
 675           break;
 676         }
 677     }
 678
 679   return TRUE;
 680 }
 681
 682 /* This must exist if dynobj is ever set.  */
 683
 684 static bfd_boolean
 685 m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
 686                                   struct bfd_link_info *info)
 687 {
 688   bfd *dynobj;
 689   asection *splt;
 690
 691   /* As an extra sanity check, verify that all plt entries have
 692      been filled in.  */
 693
 694   if ((dynobj = elf_hash_table (info)->dynobj) != NULL
 695       && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
 696     {
 697       bfd_byte *contents = splt->contents;
 698       unsigned int i, size = splt->size;
 699       for (i = 0; i < size; i += 4)
 700         {
 701           unsigned int x = bfd_get_32 (dynobj, contents + i);
 702           BFD_ASSERT (x != 0);
 703         }
 704     }
 705
 706   return TRUE;
 707 }
 708
 709 static bfd_boolean
 710 m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 711                                struct bfd_link_info *info)
 712 {
 713   bfd *dynobj;
 714   asection *splt;
 715
 716   if (info->relocatable)
 717     return TRUE;
 718
 719   dynobj = elf_hash_table (info)->dynobj;
 720   if (dynobj == NULL)
 721     return TRUE;
 722
 723   splt = bfd_get_section_by_name (dynobj, ".plt");
 724   BFD_ASSERT (splt != NULL);
 725
 726   splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
 727   if (splt->contents == NULL)
 728     return FALSE;
 729
 730   return TRUE;
 731 }
 732 \f
 733 /* Function to set the ELF flag bits.  */
 734
 735 static bfd_boolean
 736 m32c_elf_set_private_flags (bfd *abfd, flagword flags)
 737 {
 738   elf_elfheader (abfd)->e_flags = flags;
 739   elf_flags_init (abfd) = TRUE;
 740   return TRUE;
 741 }
 742
 743 /* Merge backend specific data from an object file to the output
 744    object file when linking.  */
 745
 746 static bfd_boolean
 747 m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 748 {
 749   flagword old_flags, old_partial;
 750   flagword new_flags, new_partial;
 751   bfd_boolean error = FALSE;
 752   char new_opt[80];
 753   char old_opt[80];
 754
 755   new_opt[0] = old_opt[0] = '\0';
 756   new_flags = elf_elfheader (ibfd)->e_flags;
 757   old_flags = elf_elfheader (obfd)->e_flags;
 758
 759 #ifdef DEBUG
 760   (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
 761                          old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
 762                          bfd_get_filename (ibfd));
 763 #endif
 764
 765   if (!elf_flags_init (obfd))
 766     {
 767       /* First call, no flags set.  */
 768       elf_flags_init (obfd) = TRUE;
 769       elf_elfheader (obfd)->e_flags = new_flags;
 770     }
 771
 772   else if (new_flags == old_flags)
 773     /* Compatible flags are ok.  */
 774     ;
 775
 776   else          /* Possibly incompatible flags.  */
 777     {
 778       /* Warn if different cpu is used (allow a specific cpu to override
 779          the generic cpu).  */
 780       new_partial = (new_flags & EF_M32C_CPU_MASK);
 781       old_partial = (old_flags & EF_M32C_CPU_MASK);
 782       if (new_partial == old_partial)
 783         ;
 784
 785       else
 786         {
 787           switch (new_partial)
 788             {
 789             default:              strcat (new_opt, " -m16c");   break;
 790             case EF_M32C_CPU_M16C:      strcat (new_opt, " -m16c");  break;
 791             case EF_M32C_CPU_M32C:  strcat (new_opt, " -m32c");  break;
 792             }
 793
 794           switch (old_partial)
 795             {
 796             default:              strcat (old_opt, " -m16c");   break;
 797             case EF_M32C_CPU_M16C:      strcat (old_opt, " -m16c");  break;
 798             case EF_M32C_CPU_M32C:  strcat (old_opt, " -m32c");  break;
 799             }
 800         }
 801
 802       /* Print out any mismatches from above.  */
 803       if (new_opt[0])
 804         {
 805           error = TRUE;
 806           (*_bfd_error_handler)
 807             (_("%s: compiled with %s and linked with modules compiled with %s"),
 808              bfd_get_filename (ibfd), new_opt, old_opt);
 809         }
 810
 811       new_flags &= ~ EF_M32C_ALL_FLAGS;
 812       old_flags &= ~ EF_M32C_ALL_FLAGS;
 813
 814       /* Warn about any other mismatches.  */
 815       if (new_flags != old_flags)
 816         {
 817           error = TRUE;
 818           (*_bfd_error_handler)
 819             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
 820              bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
 821         }
 822     }
 823
 824   if (error)
 825     bfd_set_error (bfd_error_bad_value);
 826
 827   return !error;
 828 }
 829
 830 \f
 831 static bfd_boolean
 832 m32c_elf_print_private_bfd_data (bfd *abfd, PTR ptr)
 833 {
 834   FILE *file = (FILE *) ptr;
 835   flagword flags;
 836
 837   BFD_ASSERT (abfd != NULL && ptr != NULL);
 838
 839   /* Print normal ELF private data.  */
 840   _bfd_elf_print_private_bfd_data (abfd, ptr);
 841
 842   flags = elf_elfheader (abfd)->e_flags;
 843   fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
 844
 845   switch (flags & EF_M32C_CPU_MASK)
 846     {
 847     default:                                                    break;
 848     case EF_M32C_CPU_M16C:      fprintf (file, " -m16c");       break;
 849     case EF_M32C_CPU_M32C:  fprintf (file, " -m32c");   break;
 850     }
 851
 852   fputc ('\n', file);
 853   return TRUE;
 854 }
 855
 856 /* Return the MACH for an e_flags value.  */
 857
 858 static int
 859 elf32_m32c_machine (bfd *abfd)
 860 {
 861   switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK)
 862     {
 863     case EF_M32C_CPU_M16C:      return bfd_mach_m16c;
 864     case EF_M32C_CPU_M32C:      return bfd_mach_m32c;
 865     }
 866
 867   return bfd_mach_m16c;
 868 }
 869
 870 static bfd_boolean
 871 m32c_elf_object_p (bfd *abfd)
 872 {
 873   bfd_default_set_arch_mach (abfd, bfd_arch_m32c,
 874                              elf32_m32c_machine (abfd));
 875   return TRUE;
 876 }
 877  \f
 878
 879 #ifdef DEBUG
 880 void
 881 dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
 882 {
 883   size_t locsymcount;
 884   Elf_Internal_Sym *isymbuf;
 885   Elf_Internal_Sym *isymend;
 886   Elf_Internal_Sym *isym;
 887   Elf_Internal_Shdr *symtab_hdr;
 888   bfd_boolean free_internal = 0, free_external = 0;
 889   char * st_info_str;
 890   char * st_info_stb_str;
 891   char * st_other_str;
 892   char * st_shndx_str;
 893
 894   if (! internal_syms)
 895     {
 896       internal_syms = bfd_malloc (1000);
 897       free_internal = 1;
 898     }
 899   if (! external_syms)
 900     {
 901       external_syms = bfd_malloc (1000);
 902       free_external = 1;
 903     }
 904
 905   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 906   locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
 907   if (free_internal)
 908     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 909                                     symtab_hdr->sh_info, 0,
 910                                     internal_syms, external_syms, NULL);
 911   else
 912     isymbuf = internal_syms;
 913   isymend = isymbuf + locsymcount;
 914
 915   for (isym = isymbuf ; isym < isymend ; isym++)
 916     {
 917       switch (ELF_ST_TYPE (isym->st_info))
 918         {
 919         case STT_FUNC: st_info_str = "STT_FUNC";
 920         case STT_SECTION: st_info_str = "STT_SECTION";
 921         case STT_FILE: st_info_str = "STT_FILE";
 922         case STT_OBJECT: st_info_str = "STT_OBJECT";
 923         case STT_TLS: st_info_str = "STT_TLS";
 924         default: st_info_str = "";
 925         }
 926       switch (ELF_ST_BIND (isym->st_info))
 927         {
 928         case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
 929         case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
 930         default: st_info_stb_str = "";
 931         }
 932       switch (ELF_ST_VISIBILITY (isym->st_other))
 933         {
 934         case STV_DEFAULT: st_other_str = "STV_DEFAULT";
 935         case STV_INTERNAL: st_other_str = "STV_INTERNAL";
 936         case STV_PROTECTED: st_other_str = "STV_PROTECTED";
 937         default: st_other_str = "";
 938         }
 939       switch (isym->st_shndx)
 940         {
 941         case SHN_ABS: st_shndx_str = "SHN_ABS";
 942         case SHN_COMMON: st_shndx_str = "SHN_COMMON";
 943         case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
 944         default: st_shndx_str = "";
 945         }
 946
 947       printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
 948               "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
 949               isym,
 950               (unsigned long) isym->st_value,
 951               (unsigned long) isym->st_size,
 952               isym->st_name,
 953               bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
 954                                                isym->st_name),
 955               isym->st_info, st_info_str, st_info_stb_str,
 956               isym->st_other, st_other_str,
 957               isym->st_shndx, st_shndx_str);
 958     }
 959   if (free_internal)
 960     free (internal_syms);
 961   if (free_external)
 962     free (external_syms);
 963 }
 964
 965 char *
 966 m32c_get_reloc (long reloc)
 967 {
 968   if (0 <= reloc && reloc < R_M32C_max)
 969     return m32c_elf_howto_table[reloc].name;
 970   else
 971     return "";
 972 }
 973 #endif /* DEBUG */
 974
 975 /* Handle relaxing.  */
 976
 977 /* A subroutine of m32c_elf_relax_section.  If the global symbol H
 978    is within the low 64k, remove any entry for it in the plt.  */
 979
 980 struct relax_plt_data
 981 {
 982   asection *splt;
 983   bfd_boolean *again;
 984 };
 985
 986 static bfd_boolean
 987 m32c_relax_plt_check (struct elf_link_hash_entry *h,
 988                       PTR xdata)
 989 {
 990   struct relax_plt_data *data = (struct relax_plt_data *) xdata;
 991
 992   if (h->root.type == bfd_link_hash_warning)
 993     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 994
 995   if (h->plt.offset != (bfd_vma) -1)
 996     {
 997       bfd_vma address;
 998
 999       if (h->root.type == bfd_link_hash_undefined
1000           || h->root.type == bfd_link_hash_undefweak)
1001         address = 0;
1002       else
1003         address = (h->root.u.def.section->output_section->vma
1004                    + h->root.u.def.section->output_offset
1005                    + h->root.u.def.value);
1006
1007       if (address <= 0xffff)
1008         {
1009           h->plt.offset = -1;
1010           data->splt->size -= 4;
1011           *data->again = TRUE;
1012         }
1013     }
1014
1015   return TRUE;
1016 }
1017
1018 /* A subroutine of m32c_elf_relax_section.  If the global symbol H
1019    previously had a plt entry, give it a new entry offset.  */
1020
1021 static bfd_boolean
1022 m32c_relax_plt_realloc (struct elf_link_hash_entry *h,
1023                         PTR xdata)
1024 {
1025   bfd_vma *entry = (bfd_vma *) xdata;
1026
1027   if (h->root.type == bfd_link_hash_warning)
1028     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1029
1030   if (h->plt.offset != (bfd_vma) -1)
1031     {
1032       h->plt.offset = *entry;
1033       *entry += 4;
1034     }
1035
1036   return TRUE;
1037 }
1038
1039 static bfd_boolean
1040 m32c_elf_relax_plt_section (bfd *dynobj,
1041                             asection *splt,
1042                             struct bfd_link_info *info,
1043                             bfd_boolean *again)
1044 {
1045   struct relax_plt_data relax_plt_data;
1046   bfd *ibfd;
1047
1048   /* Assume nothing changes.  */
1049   *again = FALSE;
1050
1051   if (info->relocatable)
1052     return TRUE;
1053
1054   /* We only relax the .plt section at the moment.  */
1055   if (dynobj != elf_hash_table (info)->dynobj
1056       || strcmp (splt->name, ".plt") != 0)
1057     return TRUE;
1058
1059   /* Quick check for an empty plt.  */
1060   if (splt->size == 0)
1061     return TRUE;
1062
1063   /* Map across all global symbols; see which ones happen to
1064      fall in the low 64k.  */
1065   relax_plt_data.splt = splt;
1066   relax_plt_data.again = again;
1067   elf_link_hash_traverse (elf_hash_table (info), m32c_relax_plt_check,
1068                           &relax_plt_data);
1069
1070   /* Likewise for local symbols, though that's somewhat less convenient
1071      as we have to walk the list of input bfds and swap in symbol data.  */
1072   for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1073     {
1074       bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1075       Elf_Internal_Shdr *symtab_hdr;
1076       Elf_Internal_Sym *isymbuf = NULL;
1077       unsigned int idx;
1078
1079       if (! local_plt_offsets)
1080         continue;
1081
1082       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1083       if (symtab_hdr->sh_info != 0)
1084         {
1085           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1086           if (isymbuf == NULL)
1087             isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1088                                             symtab_hdr->sh_info, 0,
1089                                             NULL, NULL, NULL);
1090           if (isymbuf == NULL)
1091             return FALSE;
1092         }
1093
1094       for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1095         {
1096           Elf_Internal_Sym *isym;
1097           asection *tsec;
1098           bfd_vma address;
1099
1100           if (local_plt_offsets[idx] == (bfd_vma) -1)
1101             continue;
1102
1103           isym = &isymbuf[idx];
1104           if (isym->st_shndx == SHN_UNDEF)
1105             continue;
1106           else if (isym->st_shndx == SHN_ABS)
1107             tsec = bfd_abs_section_ptr;
1108           else if (isym->st_shndx == SHN_COMMON)
1109             tsec = bfd_com_section_ptr;
1110           else
1111             tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1112
1113           address = (tsec->output_section->vma
1114                      + tsec->output_offset
1115                      + isym->st_value);
1116           if (address <= 0xffff)
1117             {
1118               local_plt_offsets[idx] = -1;
1119               splt->size -= 4;
1120               *again = TRUE;
1121             }
1122         }
1123
1124       if (isymbuf != NULL
1125           && symtab_hdr->contents != (unsigned char *) isymbuf)
1126         {
1127           if (! info->keep_memory)
1128             free (isymbuf);
1129           else
1130             {
1131               /* Cache the symbols for elf_link_input_bfd.  */
1132               symtab_hdr->contents = (unsigned char *) isymbuf;
1133             }
1134         }
1135     }
1136
1137   /* If we changed anything, walk the symbols again to reallocate
1138      .plt entry addresses.  */
1139   if (*again && splt->size > 0)
1140     {
1141       bfd_vma entry = 0;
1142
1143       elf_link_hash_traverse (elf_hash_table (info),
1144                               m32c_relax_plt_realloc, &entry);
1145
1146       for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1147         {
1148           bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1149           unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1150           unsigned int idx;
1151
1152           if (! local_plt_offsets)
1153             continue;
1154
1155           for (idx = 0; idx < nlocals; ++idx)
1156             if (local_plt_offsets[idx] != (bfd_vma) -1)
1157               {
1158                 local_plt_offsets[idx] = entry;
1159                 entry += 4;
1160               }
1161         }
1162     }
1163
1164   return TRUE;
1165 }
1166
1167 static int
1168 compare_reloc (const void *e1, const void *e2)
1169 {
1170   const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
1171   const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
1172
1173   if (i1->r_offset == i2->r_offset)
1174     return 0;
1175   else
1176     return i1->r_offset < i2->r_offset ? -1 : 1;
1177 }
1178
1179 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1180 static bfd_vma
1181 m32c_offset_for_reloc (bfd *abfd,
1182                        Elf_Internal_Rela *rel,
1183                        Elf_Internal_Shdr *symtab_hdr,
1184                        Elf_External_Sym_Shndx *shndx_buf ATTRIBUTE_UNUSED,
1185                        Elf_Internal_Sym *intsyms)
1186 {
1187   bfd_vma symval;
1188
1189   /* Get the value of the symbol referred to by the reloc.  */
1190   if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1191     {
1192       /* A local symbol.  */
1193       Elf_Internal_Sym *isym;
1194       asection *ssec;
1195
1196       isym = intsyms + ELF32_R_SYM (rel->r_info);
1197       ssec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1198       symval = isym->st_value;
1199       if (ssec)
1200         symval += ssec->output_section->vma
1201           + ssec->output_offset;
1202     }
1203   else
1204     {
1205       unsigned long indx;
1206       struct elf_link_hash_entry *h;
1207
1208       /* An external symbol.  */
1209       indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1210       h = elf_sym_hashes (abfd)[indx];
1211       BFD_ASSERT (h != NULL);
1212
1213       if (h->root.type != bfd_link_hash_defined
1214           && h->root.type != bfd_link_hash_defweak)
1215         /* This appears to be a reference to an undefined
1216            symbol.  Just ignore it--it will be caught by the
1217            regular reloc processing.  */
1218         return 0;
1219
1220       symval = (h->root.u.def.value
1221                 + h->root.u.def.section->output_section->vma
1222                 + h->root.u.def.section->output_offset);
1223     }
1224   return symval;
1225 }
1226
1227 static int bytes_saved = 0;
1228
1229 static int bytes_to_reloc[] = {
1230   R_M32C_NONE,
1231   R_M32C_8,
1232   R_M32C_16,
1233   R_M32C_24,
1234   R_M32C_32
1235 };
1236
1237 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for.  */
1238
1239 /* Mask for the number of relocs associated with this insn.  */
1240 #define RLA_RELOCS              0x0000000f
1241 /* Number of bytes gas emitted (before gas's relaxing) */
1242 #define RLA_NBYTES              0x00000ff0
1243
1244 /* If the displacement is within the given range and the new encoding
1245    differs from the old encoding (the index), then the insn can be
1246    relaxed to the new encoding.  */
1247 typedef struct {
1248   int bytes;
1249   unsigned int max_disp;
1250   unsigned char new_encoding;
1251 } EncodingTable;
1252
1253 static EncodingTable m16c_addr_encodings[] = {
1254   { 0,   0,  0 }, /* R0 */
1255   { 0,   0,  1 }, /* R1 */
1256   { 0,   0,  2 }, /* R2 */
1257   { 0,   0,  3 }, /* R3 */
1258   { 0,   0,  4 }, /* A0 */
1259   { 0,   0,  5 }, /* A1 */
1260   { 0,   0,  6 }, /* [A0] */
1261   { 0,   0,  7 }, /* [A1] */
1262   { 1,   0,  6 }, /* udsp:8[A0] */
1263   { 1,   0,  7 }, /* udsp:8[A1] */
1264   { 1,   0, 10 }, /* udsp:8[SB] */
1265   { 1,   0, 11 }, /* sdsp:8[FB] */
1266   { 2, 255,  8 }, /* udsp:16[A0] */
1267   { 2, 255,  9 }, /* udsp:16[A1] */
1268   { 2, 255, 10 }, /* udsp:16[SB] */
1269   { 2,   0, 15 }, /* abs:16 */
1270 };
1271
1272 static EncodingTable m16c_jmpaddr_encodings[] = {
1273   { 0,   0,  0 }, /* R0 */
1274   { 0,   0,  1 }, /* R1 */
1275   { 0,   0,  2 }, /* R2 */
1276   { 0,   0,  3 }, /* R3 */
1277   { 0,   0,  4 }, /* A0 */
1278   { 0,   0,  5 }, /* A1 */
1279   { 0,   0,  6 }, /* [A0] */
1280   { 0,   0,  7 }, /* [A1] */
1281   { 1,   0,  6 }, /* udsp:8[A0] */
1282   { 1,   0,  7 }, /* udsp:8[A1] */
1283   { 1,   0, 10 }, /* udsp:8[SB] */
1284   { 1,   0, 11 }, /* sdsp:8[FB] */
1285   { 3, 255,  8 }, /* udsp:20[A0] */
1286   { 3, 255,  9 }, /* udsp:20[A1] */
1287   { 2, 255, 10 }, /* udsp:16[SB] */
1288   { 2,   0, 15 }, /* abs:16 */
1289 };
1290
1291 static EncodingTable m32c_addr_encodings[] = {
1292   { 0,     0,  0 }, /* [A0] */
1293   { 0,     0,  1 }, /* [A1] */
1294   { 0,     0,  2 }, /* A0 */
1295   { 0,     0,  3 }, /* A1 */
1296   { 1,     0,  0 }, /* udsp:8[A0] */
1297   { 1,     0,  1 }, /* udsp:8[A1] */
1298   { 1,     0,  6 }, /* udsp:8[SB] */
1299   { 1,     0,  7 }, /* sdsp:8[FB] */
1300   { 2,   255,  4 }, /* udsp:16[A0] */
1301   { 2,   255,  5 }, /* udsp:16[A1] */
1302   { 2,   255,  6 }, /* udsp:16[SB] */
1303   { 2,   127,  7 }, /* sdsp:16[FB] */
1304   { 3, 65535, 8 }, /* udsp:24[A0] */
1305   { 3, 65535, 9 }, /* udsp:24[A1] */
1306   { 3, 65535, 15 }, /* abs24 */
1307   { 2,     0, 15 }, /* abs16 */
1308   { 0,     0, 16 }, /* R2 */
1309   { 0,     0, 17 }, /* R3 */
1310   { 0,     0, 18 }, /* R0 */
1311   { 0,     0, 19 }, /* R1 */
1312   { 0,     0, 20 }, /*  */
1313   { 0,     0, 21 }, /*  */
1314   { 0,     0, 22 }, /*  */
1315   { 0,     0, 23 }, /*  */
1316   { 0,     0, 24 }, /*  */
1317   { 0,     0, 25 }, /*  */
1318   { 0,     0, 26 }, /*  */
1319   { 0,     0, 27 }, /*  */
1320   { 0,     0, 28 }, /*  */
1321   { 0,     0, 29 }, /*  */
1322   { 0,     0, 30 }, /*  */
1323   { 0,     0, 31 }, /*  */
1324 };
1325
1326 static bfd_boolean
1327 m32c_elf_relax_section
1328     (bfd *                  abfd,
1329      asection *             sec,
1330      struct bfd_link_info * link_info,
1331      bfd_boolean *          again)
1332 {
1333   Elf_Internal_Shdr *symtab_hdr;
1334   Elf_Internal_Shdr *shndx_hdr;
1335   Elf_Internal_Rela *internal_relocs;
1336   Elf_Internal_Rela *free_relocs = NULL;
1337   Elf_Internal_Rela *irel, *irelend, *srel;
1338   bfd_byte * contents = NULL;
1339   bfd_byte * free_contents = NULL;
1340   Elf_Internal_Sym *intsyms = NULL;
1341   Elf_Internal_Sym *free_intsyms = NULL;
1342   Elf_External_Sym_Shndx *shndx_buf = NULL;
1343   int machine;
1344
1345   if (abfd == elf_hash_table (link_info)->dynobj
1346       && strcmp (sec->name, ".plt") == 0)
1347     return m32c_elf_relax_plt_section (abfd, sec, link_info, again);
1348
1349   /* Assume nothing changes.  */
1350   *again = FALSE;
1351
1352   machine = elf32_m32c_machine (abfd);
1353
1354   /* We don't have to do anything for a relocatable link, if
1355      this section does not have relocs, or if this is not a
1356      code section.  */
1357   if (link_info->relocatable
1358       || (sec->flags & SEC_RELOC) == 0
1359       || sec->reloc_count == 0
1360       || (sec->flags & SEC_CODE) == 0)
1361     return TRUE;
1362
1363   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1364   shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1365
1366   /* Get the section contents.  */
1367   if (elf_section_data (sec)->this_hdr.contents != NULL)
1368     contents = elf_section_data (sec)->this_hdr.contents;
1369   /* Go get them off disk.  */
1370   else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1371     goto error_return;
1372
1373   /* Read this BFD's symbols.  */
1374   /* Get cached copy if it exists.  */
1375   if (symtab_hdr->contents != NULL)
1376     {
1377       intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1378     }
1379   else
1380     {
1381       intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
1382       symtab_hdr->contents = (bfd_byte *) intsyms;
1383     }
1384
1385   if (shndx_hdr->sh_size != 0)
1386     {
1387       bfd_size_type amt;
1388
1389       amt = symtab_hdr->sh_info;
1390       amt *= sizeof (Elf_External_Sym_Shndx);
1391       shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1392       if (shndx_buf == NULL)
1393         goto error_return;
1394       if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1395           || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
1396         goto error_return;
1397       shndx_hdr->contents = (bfd_byte *) shndx_buf;
1398     }
1399
1400   /* Get a copy of the native relocations.  */
1401   internal_relocs = (_bfd_elf_link_read_relocs
1402                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1403                       link_info->keep_memory));
1404   if (internal_relocs == NULL)
1405     goto error_return;
1406   if (! link_info->keep_memory)
1407     free_relocs = internal_relocs;
1408
1409   /* The RL_ relocs must be just before the operand relocs they go
1410      with, so we must sort them to guarantee this.  */
1411   qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
1412          compare_reloc);
1413
1414   /* Walk through them looking for relaxing opportunities.  */
1415   irelend = internal_relocs + sec->reloc_count;
1416
1417   for (irel = internal_relocs; irel < irelend; irel++)
1418     {
1419       bfd_vma symval;
1420       unsigned char *insn, *gap, *einsn;
1421       bfd_vma pc;
1422       bfd_signed_vma pcrel;
1423       int relax_relocs;
1424       int gap_size;
1425       int new_type;
1426       int posn;
1427       int enc;
1428       EncodingTable *enctbl;
1429       EncodingTable *e;
1430
1431       if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP
1432           && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR
1433           && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR)
1434         continue;
1435
1436       srel = irel;
1437
1438       /* There will always be room for the relaxed insn, since it is smaller
1439          than the one it would replace.  */
1440       BFD_ASSERT (irel->r_offset < sec->size);
1441
1442       insn = contents + irel->r_offset;
1443       relax_relocs = irel->r_addend % 16;
1444
1445       /* Ok, we only have three relocs we care about, and they're all
1446          fake.  The lower four bits of the addend is always the number
1447          of following relocs (hence the qsort above) that are assigned
1448          to this opcode.  The next 8 bits of the addend indicates the
1449          number of bytes in the insn.  We use the rest of them
1450          ourselves as flags for the more expensive operations (defines
1451          above).  The three relocs are:
1452
1453          RL_JUMP: This marks all direct jump insns.  We check the
1454                 displacement and replace them with shorter jumps if
1455                 they're in range.  We also use this to find JMP.S
1456                 insns and manually shorten them when we delete bytes.
1457                 We have to decode these insns to figure out what to
1458                 do.
1459
1460          RL_1ADDR: This is a :G or :Q insn, which has a single
1461                 "standard" operand.  We have to extract the type
1462                 field, see if it's a wide displacement, then figure
1463                 out if we can replace it with a narrow displacement.
1464                 We don't have to decode these insns.
1465
1466          RL_2ADDR: Similarly, but two "standard" operands.  Note that
1467                 r_addend may still be 1, as standard operands don't
1468                 always have displacements.  Gas shouldn't give us one
1469                 with zero operands, but since we don't know which one
1470                 has the displacement, we check them both anyway.
1471
1472          These all point to the beginning of the insn itself, not the
1473          operands.
1474
1475          Note that we only relax one step at a time, relying on the
1476          linker to call us repeatedly.  Thus, there is no code for
1477          JMP.A->JMP.B although that will happen in two steps.
1478          Likewise, for 2ADDR relaxes, we do one operand per cycle.
1479       */
1480
1481       /* Get the value of the symbol referred to by the reloc.  Just
1482          in case this is the last reloc in the list, use the RL's
1483          addend to choose between this reloc (no addend) or the next
1484          (yes addend, which means at least one following reloc).  */
1485       srel = irel + (relax_relocs ? 1 : 0);
1486       symval = OFFSET_FOR_RELOC (srel);
1487
1488       /* Setting gap_size nonzero is the flag which means "something
1489          shrunk".  */
1490       gap_size = 0;
1491       gap = NULL;
1492       new_type = ELF32_R_TYPE(srel->r_info);
1493
1494       pc = sec->output_section->vma + sec->output_offset
1495         + srel->r_offset;
1496       pcrel = symval - pc + srel->r_addend;
1497
1498       if (machine == bfd_mach_m16c)
1499         {
1500           /* R8C / M16C */
1501
1502           switch (ELF32_R_TYPE(irel->r_info))
1503             {
1504
1505             case R_M32C_RL_JUMP:
1506               switch (insn[0])
1507                 {
1508                 case 0xfe: /* jmp.b */
1509                   if (pcrel >= 2 && pcrel <= 9)
1510                     {
1511                       /* Relax JMP.B -> JMP.S.  We need to get rid of
1512                          the following reloc though. */
1513                       insn[0] = 0x60 | (pcrel - 2);
1514                       new_type = R_M32C_NONE;
1515                       irel->r_addend = 0x10;
1516                       gap_size = 1;
1517                       gap = insn + 1;
1518                     }
1519                   break;
1520
1521                 case 0xf4: /* jmp.w */
1522                   /* 128 is allowed because it will be one byte closer
1523                      after relaxing.  Likewise for all other pc-rel
1524                      jumps.  */
1525                   if (pcrel <= 128 && pcrel >= -128)
1526                     {
1527                       /* Relax JMP.W -> JMP.B */
1528                       insn[0] = 0xfe;
1529                       insn[1] = 0;
1530                       new_type = R_M32C_8_PCREL;
1531                       gap_size = 1;
1532                       gap = insn + 2;
1533                     }
1534                   break;
1535
1536                 case 0xfc: /* jmp.a */
1537                   if (pcrel <= 32768 && pcrel >= -32768)
1538                     {
1539                       /* Relax JMP.A -> JMP.W */
1540                       insn[0] = 0xf4;
1541                       insn[1] = 0;
1542                       insn[2] = 0;
1543                       new_type = R_M32C_16_PCREL;
1544                       gap_size = 1;
1545                       gap = insn + 3;
1546                     }
1547                   break;
1548
1549                 case 0xfd: /* jsr.a */
1550                   if (pcrel <= 32768 && pcrel >= -32768)
1551                     {
1552                       /* Relax JSR.A -> JSR.W */
1553                       insn[0] = 0xf5;
1554                       insn[1] = 0;
1555                       insn[2] = 0;
1556                       new_type = R_M32C_16_PCREL;
1557                       gap_size = 1;
1558                       gap = insn + 3;
1559                     }
1560                   break;
1561                 }
1562               break;
1563
1564             case R_M32C_RL_2ADDR:
1565               /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1566
1567               enctbl = m16c_addr_encodings;
1568               posn = 2;
1569               enc = (insn[1] >> 4) & 0x0f;
1570               e = & enctbl[enc];
1571
1572               if (srel->r_offset == irel->r_offset + posn
1573                   && e->new_encoding != enc
1574                   && symval <= e->max_disp)
1575                 {
1576                   insn[1] &= 0x0f;
1577                   insn[1] |= e->new_encoding << 4;
1578                   gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1579                   gap = insn + posn + enctbl[e->new_encoding].bytes;
1580                   new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1581                   break;
1582                 }
1583               if (relax_relocs == 2)
1584                 srel ++;
1585               posn += e->bytes;
1586
1587               goto try_1addr_16;
1588
1589             case R_M32C_RL_1ADDR:
1590               /* xxxx xxxx xxxx dest [disp] */
1591
1592               enctbl = m16c_addr_encodings;
1593               posn = 2;
1594
1595               /* Check the opcode for jumps.  We know it's safe to
1596                  do this because all 2ADDR insns are at least two
1597                  bytes long.  */
1598               enc = insn[0] * 256 + insn[1];
1599               enc &= 0xfff0;
1600               if (enc == 0x7d20
1601                   || enc == 0x7d00
1602                   || enc == 0x7d30
1603                   || enc == 0x7d10)
1604                 {
1605                   enctbl = m16c_jmpaddr_encodings;
1606                 }
1607
1608             try_1addr_16:
1609               /* srel, posn, and enc must be set here.  */
1610
1611               symval = OFFSET_FOR_RELOC (srel);
1612               enc = insn[1] & 0x0f;
1613               e = & enctbl[enc];
1614
1615               if (srel->r_offset == irel->r_offset + posn
1616                   && e->new_encoding != enc
1617                   && symval <= e->max_disp)
1618                 {
1619                   insn[1] &= 0xf0;
1620                   insn[1] |= e->new_encoding;
1621                   gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1622                   gap = insn + posn + enctbl[e->new_encoding].bytes;
1623                   new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1624                   break;
1625                 }
1626
1627               break;
1628
1629             } /* Ends switch (reloc type) for m16c.  */
1630         }
1631       else /* machine == bfd_mach_m32c */
1632         {
1633           /* M32CM / M32C */
1634
1635           switch (ELF32_R_TYPE(irel->r_info))
1636             {
1637
1638             case R_M32C_RL_JUMP:
1639               switch (insn[0])
1640                 {
1641                 case 0xbb: /* jmp.b */
1642                   if (pcrel >= 2 && pcrel <= 9)
1643                     {
1644                       int p = pcrel - 2;
1645                       /* Relax JMP.B -> JMP.S.  We need to get rid of
1646                          the following reloc though. */
1647                       insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1);
1648                       new_type = R_M32C_NONE;
1649                       irel->r_addend = 0x10;
1650                       gap_size = 1;
1651                       gap = insn + 1;
1652                     }
1653                   break;
1654
1655                 case 0xce: /* jmp.w */
1656                   if (pcrel <= 128 && pcrel >= -128)
1657                     {
1658                       /* Relax JMP.W -> JMP.B */
1659                       insn[0] = 0xbb;
1660                       insn[1] = 0;
1661                       new_type = R_M32C_8_PCREL;
1662                       gap_size = 1;
1663                       gap = insn + 2;
1664                     }
1665                   break;
1666
1667                 case 0xcc: /* jmp.a */
1668                   if (pcrel <= 32768 && pcrel >= -32768)
1669                     {
1670                       /* Relax JMP.A -> JMP.W */
1671                       insn[0] = 0xce;
1672                       insn[1] = 0;
1673                       insn[2] = 0;
1674                       new_type = R_M32C_16_PCREL;
1675                       gap_size = 1;
1676                       gap = insn + 3;
1677                     }
1678                   break;
1679
1680                 case 0xcd: /* jsr.a */
1681                   if (pcrel <= 32768 && pcrel >= -32768)
1682                     {
1683                       /* Relax JSR.A -> JSR.W */
1684                       insn[0] = 0xcf;
1685                       insn[1] = 0;
1686                       insn[2] = 0;
1687                       new_type = R_M32C_16_PCREL;
1688                       gap_size = 1;
1689                       gap = insn + 3;
1690                     }
1691                   break;
1692                 }
1693               break;
1694
1695             case R_M32C_RL_2ADDR:
1696               /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1697
1698               einsn = insn;
1699               posn = 2;
1700               if (einsn[0] == 1)
1701                 {
1702                   /* prefix; remove it as far as the RL reloc is concerned.  */
1703                   einsn ++;
1704                   posn ++;
1705                 }
1706
1707               enctbl = m32c_addr_encodings;
1708               enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4);
1709               e = & enctbl[enc];
1710
1711               if (srel->r_offset == irel->r_offset + posn
1712                   && e->new_encoding != enc
1713                   && symval <= e->max_disp)
1714                 {
1715                   einsn[0] &= 0x8f;
1716                   einsn[0] |= (e->new_encoding & 0x1c) << 2;
1717                   einsn[1] &= 0xcf;
1718                   einsn[1] |= (e->new_encoding & 0x03) << 4;
1719                   gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1720                   gap = insn + posn + enctbl[e->new_encoding].bytes;
1721                   new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1722                   break;
1723                 }
1724               if (relax_relocs == 2)
1725                   srel ++;
1726               posn += e->bytes;
1727
1728               goto try_1addr_32;
1729
1730             case R_M32C_RL_1ADDR:
1731               /* xxxx DDDx DDxx xxxx [disp] */
1732
1733               einsn = insn;
1734               posn = 2;
1735               if (einsn[0] == 1)
1736                 {
1737                   /* prefix; remove it as far as the RL reloc is concerned.  */
1738                   einsn ++;
1739                   posn ++;
1740                 }
1741
1742               enctbl = m32c_addr_encodings;
1743
1744             try_1addr_32:
1745               /* srel, posn, and enc must be set here.  */
1746
1747               symval = OFFSET_FOR_RELOC (srel);
1748               enc = ((einsn[0] & 0x0e) << 1) |  ((einsn[1] & 0xc0) >> 6);
1749               e = & enctbl[enc];
1750
1751               if (srel->r_offset == irel->r_offset + posn
1752                   && e->new_encoding != enc
1753                   && symval <= e->max_disp)
1754                 {
1755                   einsn[0] &= 0xf1;
1756                   einsn[0] |= (e->new_encoding & 0x1c) >> 1;
1757                   einsn[1] &= 0x3f;
1758                   einsn[1] |= (e->new_encoding & 0x03) << 6;
1759                   gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1760                   gap = insn + posn + enctbl[e->new_encoding].bytes;
1761                   new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1762                   break;
1763                 }
1764
1765               break;
1766
1767             } /* Ends switch (reloc type) for m32c.  */
1768         }
1769
1770       if (gap_size == 0)
1771         continue;
1772
1773       *again = TRUE;
1774
1775       srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type);
1776
1777       /* Note that we've changed the relocs, section contents, etc.  */
1778       elf_section_data (sec)->relocs = internal_relocs;
1779       free_relocs = NULL;
1780
1781       elf_section_data (sec)->this_hdr.contents = contents;
1782       free_contents = NULL;
1783
1784       symtab_hdr->contents = (bfd_byte *) intsyms;
1785       free_intsyms = NULL;
1786
1787       bytes_saved += gap_size;
1788
1789       if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size))
1790         goto error_return;
1791
1792     } /* next relocation */
1793
1794   if (free_relocs != NULL)
1795     {
1796       free (free_relocs);
1797       free_relocs = NULL;
1798     }
1799
1800   if (free_contents != NULL)
1801     {
1802       if (! link_info->keep_memory)
1803         free (free_contents);
1804       /* Cache the section contents for elf_link_input_bfd.  */
1805       else
1806         elf_section_data (sec)->this_hdr.contents = contents;
1807
1808       free_contents = NULL;
1809     }
1810
1811   if (shndx_buf != NULL)
1812     {
1813       shndx_hdr->contents = NULL;
1814       free (shndx_buf);
1815     }
1816
1817   if (free_intsyms != NULL)
1818     {
1819       if (! link_info->keep_memory)
1820         free (free_intsyms);
1821       /* Cache the symbols for elf_link_input_bfd.  */
1822       else
1823         {
1824         symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/;
1825         }
1826
1827       free_intsyms = NULL;
1828     }
1829
1830   return TRUE;
1831
1832  error_return:
1833   if (free_relocs != NULL)
1834     free (free_relocs);
1835   if (free_contents != NULL)
1836     free (free_contents);
1837   if (shndx_buf != NULL)
1838     {
1839       shndx_hdr->contents = NULL;
1840       free (shndx_buf);
1841     }
1842   if (free_intsyms != NULL)
1843     free (free_intsyms);
1844   return FALSE;
1845 }
1846
1847 /* Delete some bytes from a section while relaxing.  */
1848
1849 static bfd_boolean
1850 m32c_elf_relax_delete_bytes
1851  (bfd *      abfd,
1852   asection * sec,
1853   bfd_vma    addr,
1854   int        count)
1855 {
1856   Elf_Internal_Shdr *symtab_hdr;
1857   Elf_Internal_Shdr *shndx_hdr;
1858   int sec_shndx;
1859   bfd_byte *contents;
1860   Elf_Internal_Rela *irel;
1861   Elf_Internal_Rela *irelend;
1862   bfd_vma toaddr;
1863   Elf_Internal_Sym *isym;
1864   Elf_Internal_Sym *isymend;
1865   Elf_Internal_Sym *intsyms;
1866   Elf_External_Sym_Shndx *shndx_buf;
1867   Elf_External_Sym_Shndx *shndx;
1868   struct elf_link_hash_entry ** sym_hashes;
1869   struct elf_link_hash_entry ** end_hashes;
1870   unsigned int                  symcount;
1871
1872   contents   = elf_section_data (sec)->this_hdr.contents;
1873
1874   toaddr = sec->size;
1875
1876   irel = elf_section_data (sec)->relocs;
1877   irelend = irel + sec->reloc_count;
1878
1879   /* Actually delete the bytes.  */
1880   memmove (contents + addr, contents + addr + count, (size_t) (toaddr - addr - count));
1881   sec->size -= count;
1882
1883   /* Adjust all the relocs.  */
1884   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel ++)
1885     {
1886       /* Get the new reloc address.  */
1887       if (irel->r_offset > addr && irel->r_offset < toaddr)
1888         irel->r_offset -= count;
1889
1890       if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP
1891           && irel->r_addend == 0x10 /* one byte insn, no relocs */
1892           && irel->r_offset + 1 < addr
1893           && irel->r_offset + 7 > addr)
1894         {
1895           bfd_vma disp;
1896           unsigned char *insn = &contents[irel->r_offset];
1897           disp = *insn;
1898           /* This is a JMP.S, which we have to manually update. */
1899           if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
1900             {
1901               if ((*insn & 0xf8) != 0x60)
1902                 continue;
1903               disp = (disp & 7);
1904             }
1905           else
1906             {
1907               if ((*insn & 0xce) != 0x4a)
1908                 continue;
1909               disp = ((disp & 0x30) >> 3) | (disp & 1);
1910             }
1911           if (irel->r_offset + disp + 2 >= addr+count)
1912             {
1913               disp -= count;
1914               if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
1915                 {
1916                   *insn = (*insn & 0xf8) | disp;
1917                 }
1918               else
1919                 {
1920                   *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1);
1921                 }
1922             }
1923         }
1924     }
1925
1926   /* Adjust the local symbols defined in this section.  */
1927   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1928   intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1929   isym = intsyms;
1930   isymend = isym + symtab_hdr->sh_info;
1931
1932   sec_shndx  = _bfd_elf_section_from_bfd_section (abfd, sec);
1933   shndx_hdr  = & elf_tdata (abfd)->symtab_shndx_hdr;
1934   shndx_buf  = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
1935   shndx = shndx_buf;
1936
1937   for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL))
1938     {
1939       /* If the symbol is in the range of memory we just moved, we
1940          have to adjust its value.  */
1941       if ((int) isym->st_shndx == sec_shndx
1942           && isym->st_value > addr
1943           && isym->st_value < toaddr)
1944         {
1945           isym->st_value -= count;
1946         }
1947       /* If the symbol *spans* the bytes we just deleted (i.e. it's
1948          *end* is in the moved bytes but it's *start* isn't), then we
1949          must adjust its size.  */
1950       if ((int) isym->st_shndx == sec_shndx
1951             && isym->st_value < addr
1952           && isym->st_value + isym->st_size > addr
1953           && isym->st_value + isym->st_size < toaddr)
1954         {
1955           isym->st_size -= count;
1956         }
1957     }
1958
1959   /* Now adjust the global symbols defined in this section.  */
1960   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1961               - symtab_hdr->sh_info);
1962   sym_hashes = elf_sym_hashes (abfd);
1963   //  sym_hashes += symtab_hdr->sh_info;
1964   end_hashes = sym_hashes + symcount;
1965
1966   for (; sym_hashes < end_hashes; sym_hashes ++)
1967     {
1968       struct elf_link_hash_entry * sym_hash = * sym_hashes;
1969
1970       if (sym_hash &&
1971           (sym_hash->root.type == bfd_link_hash_defined
1972            || sym_hash->root.type == bfd_link_hash_defweak)
1973           && sym_hash->root.u.def.section == sec)
1974         {
1975           if (sym_hash->root.u.def.value > addr
1976               && sym_hash->root.u.def.value < toaddr)
1977             {
1978               sym_hash->root.u.def.value -= count;
1979             }
1980           if (sym_hash->root.u.def.value < addr
1981               && sym_hash->root.u.def.value + sym_hash->size > addr
1982               && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1983             {
1984               sym_hash->size -= count;
1985             }
1986         }
1987     }
1988
1989   return TRUE;
1990 }
1991 \f
1992 /* This is for versions of gcc prior to 4.3.  */
1993 static unsigned int
1994 _bfd_m32c_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1995 {
1996   if ((elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK) == EF_M32C_CPU_M16C)
1997     return 2;
1998   return 4;
1999 }
2000
2001 \f
2002
2003 #define ELF_ARCH                bfd_arch_m32c
2004 #define ELF_MACHINE_CODE        EM_M32C
2005 #define ELF_MACHINE_ALT1        EM_M32C_OLD
2006 #define ELF_MAXPAGESIZE         0x100
2007
2008 #if 0
2009 #define TARGET_BIG_SYM          bfd_elf32_m32c_vec
2010 #define TARGET_BIG_NAME         "elf32-m32c"
2011 #else
2012 #define TARGET_LITTLE_SYM               bfd_elf32_m32c_vec
2013 #define TARGET_LITTLE_NAME              "elf32-m32c"
2014 #endif
2015
2016 #define elf_info_to_howto_rel                   NULL
2017 #define elf_info_to_howto                       m32c_info_to_howto_rela
2018 #define elf_backend_object_p                    m32c_elf_object_p
2019 #define elf_backend_relocate_section            m32c_elf_relocate_section
2020 #define elf_backend_check_relocs                m32c_elf_check_relocs
2021 #define elf_backend_object_p                    m32c_elf_object_p
2022 #define elf_symbol_leading_char                 ('_')
2023 #define elf_backend_always_size_sections \
2024   m32c_elf_always_size_sections
2025 #define elf_backend_finish_dynamic_sections \
2026   m32c_elf_finish_dynamic_sections
2027
2028 #define elf_backend_can_gc_sections             1
2029 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2030
2031 #define bfd_elf32_bfd_reloc_type_lookup         m32c_reloc_type_lookup
2032 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2033 #define bfd_elf32_bfd_relax_section             m32c_elf_relax_section
2034 #define bfd_elf32_bfd_set_private_flags         m32c_elf_set_private_flags
2035 #define bfd_elf32_bfd_merge_private_bfd_data    m32c_elf_merge_private_bfd_data
2036 #define bfd_elf32_bfd_print_private_bfd_data    m32c_elf_print_private_bfd_data
2037
2038 #include "elf32-target.h"