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