bfd/elf32-m32c.c

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