bfd/elf32-m32c.c

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