bfd/elf32-m32c.c

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