bfd/elf32-m32c.c

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