bfd/elf32-m32c.c

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