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