bfd/elf32-m32c.c

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