bfd/elf32-m32c.c

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