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