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