bfd/elf32-m32c.c

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