bfd/elf32-m32c.c

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