bfd/elf32-m32c.c

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