bfd/elf-m10200.c

   1 /* Matsushita 10200 specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
   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 3 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., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26
  27 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  28   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  29 static void mn10200_info_to_howto
  30   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  31 static bfd_boolean mn10200_elf_relax_delete_bytes
  32   PARAMS ((bfd *, asection *, bfd_vma, int));
  33 static bfd_boolean mn10200_elf_symbol_address_p
  34   PARAMS ((bfd *, asection *, Elf_Internal_Sym *, bfd_vma));
  35 static bfd_reloc_status_type mn10200_elf_final_link_relocate
  36   PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *,
  37            bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
  38            struct bfd_link_info *, asection *, int));
  39 static bfd_boolean mn10200_elf_relocate_section
  40   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
  41            bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *,
  42            asection **));
  43 static bfd_boolean mn10200_elf_relax_section
  44   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
  45 static bfd_byte * mn10200_elf_get_relocated_section_contents
  46   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
  47            bfd_byte *, bfd_boolean, asymbol **));
  48
  49 enum reloc_type {
  50   R_MN10200_NONE = 0,
  51   R_MN10200_32,
  52   R_MN10200_16,
  53   R_MN10200_8,
  54   R_MN10200_24,
  55   R_MN10200_PCREL8,
  56   R_MN10200_PCREL16,
  57   R_MN10200_PCREL24,
  58   R_MN10200_MAX
  59 };
  60
  61 static reloc_howto_type elf_mn10200_howto_table[] = {
  62   /* Dummy relocation.  Does nothing.  */
  63   HOWTO (R_MN10200_NONE,
  64          0,
  65          2,
  66          16,
  67          FALSE,
  68          0,
  69          complain_overflow_bitfield,
  70          bfd_elf_generic_reloc,
  71          "R_MN10200_NONE",
  72          FALSE,
  73          0,
  74          0,
  75          FALSE),
  76   /* Standard 32 bit reloc.  */
  77   HOWTO (R_MN10200_32,
  78          0,
  79          2,
  80          32,
  81          FALSE,
  82          0,
  83          complain_overflow_bitfield,
  84          bfd_elf_generic_reloc,
  85          "R_MN10200_32",
  86          FALSE,
  87          0xffffffff,
  88          0xffffffff,
  89          FALSE),
  90   /* Standard 16 bit reloc.  */
  91   HOWTO (R_MN10200_16,
  92          0,
  93          1,
  94          16,
  95          FALSE,
  96          0,
  97          complain_overflow_bitfield,
  98          bfd_elf_generic_reloc,
  99          "R_MN10200_16",
 100          FALSE,
 101          0xffff,
 102          0xffff,
 103          FALSE),
 104   /* Standard 8 bit reloc.  */
 105   HOWTO (R_MN10200_8,
 106          0,
 107          0,
 108          8,
 109          FALSE,
 110          0,
 111          complain_overflow_bitfield,
 112          bfd_elf_generic_reloc,
 113          "R_MN10200_8",
 114          FALSE,
 115          0xff,
 116          0xff,
 117          FALSE),
 118   /* Standard 24 bit reloc.  */
 119   HOWTO (R_MN10200_24,
 120          0,
 121          2,
 122          24,
 123          FALSE,
 124          0,
 125          complain_overflow_bitfield,
 126          bfd_elf_generic_reloc,
 127          "R_MN10200_24",
 128          FALSE,
 129          0xffffff,
 130          0xffffff,
 131          FALSE),
 132   /* Simple 8 pc-relative reloc.  */
 133   HOWTO (R_MN10200_PCREL8,
 134          0,
 135          0,
 136          8,
 137          TRUE,
 138          0,
 139          complain_overflow_bitfield,
 140          bfd_elf_generic_reloc,
 141          "R_MN10200_PCREL8",
 142          FALSE,
 143          0xff,
 144          0xff,
 145          TRUE),
 146   /* Simple 16 pc-relative reloc.  */
 147   HOWTO (R_MN10200_PCREL16,
 148          0,
 149          1,
 150          16,
 151          TRUE,
 152          0,
 153          complain_overflow_bitfield,
 154          bfd_elf_generic_reloc,
 155          "R_MN10200_PCREL16",
 156          FALSE,
 157          0xffff,
 158          0xffff,
 159          TRUE),
 160   /* Simple 32bit pc-relative reloc with a 1 byte adjustment
 161      to get the pc-relative offset correct.  */
 162   HOWTO (R_MN10200_PCREL24,
 163          0,
 164          2,
 165          24,
 166          TRUE,
 167          0,
 168          complain_overflow_bitfield,
 169          bfd_elf_generic_reloc,
 170          "R_MN10200_PCREL24",
 171          FALSE,
 172          0xffffff,
 173          0xffffff,
 174          TRUE),
 175 };
 176
 177 struct mn10200_reloc_map {
 178   bfd_reloc_code_real_type bfd_reloc_val;
 179   unsigned char elf_reloc_val;
 180 };
 181
 182 static const struct mn10200_reloc_map mn10200_reloc_map[] = {
 183   { BFD_RELOC_NONE    , R_MN10200_NONE   , },
 184   { BFD_RELOC_32      , R_MN10200_32     , },
 185   { BFD_RELOC_16      , R_MN10200_16     , },
 186   { BFD_RELOC_8       , R_MN10200_8      , },
 187   { BFD_RELOC_24      , R_MN10200_24     , },
 188   { BFD_RELOC_8_PCREL , R_MN10200_PCREL8 , },
 189   { BFD_RELOC_16_PCREL, R_MN10200_PCREL16, },
 190   { BFD_RELOC_24_PCREL, R_MN10200_PCREL24, },
 191 };
 192
 193 static reloc_howto_type *
 194 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
 195      bfd *abfd ATTRIBUTE_UNUSED;
 196      bfd_reloc_code_real_type code;
 197 {
 198   unsigned int i;
 199
 200   for (i = 0;
 201        i < sizeof (mn10200_reloc_map) / sizeof (struct mn10200_reloc_map);
 202        i++)
 203     {
 204       if (mn10200_reloc_map[i].bfd_reloc_val == code)
 205         return &elf_mn10200_howto_table[mn10200_reloc_map[i].elf_reloc_val];
 206     }
 207
 208   return NULL;
 209 }
 210
 211 static reloc_howto_type *
 212 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 213                                  const char *r_name)
 214 {
 215   unsigned int i;
 216
 217   for (i = 0;
 218        i < (sizeof (elf_mn10200_howto_table)
 219             / sizeof (elf_mn10200_howto_table[0]));
 220        i++)
 221     if (elf_mn10200_howto_table[i].name != NULL
 222         && strcasecmp (elf_mn10200_howto_table[i].name, r_name) == 0)
 223       return &elf_mn10200_howto_table[i];
 224
 225   return NULL;
 226 }
 227
 228 /* Set the howto pointer for an MN10200 ELF reloc.  */
 229
 230 static void
 231 mn10200_info_to_howto (abfd, cache_ptr, dst)
 232      bfd *abfd ATTRIBUTE_UNUSED;
 233      arelent *cache_ptr;
 234      Elf_Internal_Rela *dst;
 235 {
 236   unsigned int r_type;
 237
 238   r_type = ELF32_R_TYPE (dst->r_info);
 239   BFD_ASSERT (r_type < (unsigned int) R_MN10200_MAX);
 240   cache_ptr->howto = &elf_mn10200_howto_table[r_type];
 241 }
 242
 243 /* Perform a relocation as part of a final link.  */
 244
 245 static bfd_reloc_status_type
 246 mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
 247                                  input_section, contents, offset, value,
 248                                  addend, info, sym_sec, is_local)
 249      reloc_howto_type *howto;
 250      bfd *input_bfd;
 251      bfd *output_bfd ATTRIBUTE_UNUSED;
 252      asection *input_section;
 253      bfd_byte *contents;
 254      bfd_vma offset;
 255      bfd_vma value;
 256      bfd_vma addend;
 257      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 258      asection *sym_sec ATTRIBUTE_UNUSED;
 259      int is_local ATTRIBUTE_UNUSED;
 260 {
 261   unsigned long r_type = howto->type;
 262   bfd_byte *hit_data = contents + offset;
 263
 264   switch (r_type)
 265     {
 266
 267     case R_MN10200_NONE:
 268       return bfd_reloc_ok;
 269
 270     case R_MN10200_32:
 271       value += addend;
 272       bfd_put_32 (input_bfd, value, hit_data);
 273       return bfd_reloc_ok;
 274
 275     case R_MN10200_16:
 276       value += addend;
 277
 278       if ((long) value > 0x7fff || (long) value < -0x8000)
 279         return bfd_reloc_overflow;
 280
 281       bfd_put_16 (input_bfd, value, hit_data);
 282       return bfd_reloc_ok;
 283
 284     case R_MN10200_8:
 285       value += addend;
 286
 287       if ((long) value > 0x7f || (long) value < -0x80)
 288         return bfd_reloc_overflow;
 289
 290       bfd_put_8 (input_bfd, value, hit_data);
 291       return bfd_reloc_ok;
 292
 293     case R_MN10200_24:
 294       value += addend;
 295
 296       if ((long) value > 0x7fffff || (long) value < -0x800000)
 297         return bfd_reloc_overflow;
 298
 299       value &= 0xffffff;
 300       value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
 301       bfd_put_32 (input_bfd, value, hit_data);
 302       return bfd_reloc_ok;
 303
 304     case R_MN10200_PCREL8:
 305       value -= (input_section->output_section->vma
 306                 + input_section->output_offset);
 307       value -= (offset + 1);
 308       value += addend;
 309
 310       if ((long) value > 0xff || (long) value < -0x100)
 311         return bfd_reloc_overflow;
 312
 313       bfd_put_8 (input_bfd, value, hit_data);
 314       return bfd_reloc_ok;
 315
 316     case R_MN10200_PCREL16:
 317       value -= (input_section->output_section->vma
 318                 + input_section->output_offset);
 319       value -= (offset + 2);
 320       value += addend;
 321
 322       if ((long) value > 0xffff || (long) value < -0x10000)
 323         return bfd_reloc_overflow;
 324
 325       bfd_put_16 (input_bfd, value, hit_data);
 326       return bfd_reloc_ok;
 327
 328     case R_MN10200_PCREL24:
 329       value -= (input_section->output_section->vma
 330                 + input_section->output_offset);
 331       value -= (offset + 3);
 332       value += addend;
 333
 334       if ((long) value > 0xffffff || (long) value < -0x1000000)
 335         return bfd_reloc_overflow;
 336
 337       value &= 0xffffff;
 338       value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
 339       bfd_put_32 (input_bfd, value, hit_data);
 340       return bfd_reloc_ok;
 341
 342     default:
 343       return bfd_reloc_notsupported;
 344     }
 345 }
 346 \f
 347 /* Relocate an MN10200 ELF section.  */
 348 static bfd_boolean
 349 mn10200_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 350                               contents, relocs, local_syms, local_sections)
 351      bfd *output_bfd;
 352      struct bfd_link_info *info;
 353      bfd *input_bfd;
 354      asection *input_section;
 355      bfd_byte *contents;
 356      Elf_Internal_Rela *relocs;
 357      Elf_Internal_Sym *local_syms;
 358      asection **local_sections;
 359 {
 360   Elf_Internal_Shdr *symtab_hdr;
 361   struct elf_link_hash_entry **sym_hashes;
 362   Elf_Internal_Rela *rel, *relend;
 363
 364   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 365   sym_hashes = elf_sym_hashes (input_bfd);
 366
 367   rel = relocs;
 368   relend = relocs + input_section->reloc_count;
 369   for (; rel < relend; rel++)
 370     {
 371       int r_type;
 372       reloc_howto_type *howto;
 373       unsigned long r_symndx;
 374       Elf_Internal_Sym *sym;
 375       asection *sec;
 376       struct elf_link_hash_entry *h;
 377       bfd_vma relocation;
 378       bfd_reloc_status_type r;
 379
 380       r_symndx = ELF32_R_SYM (rel->r_info);
 381       r_type = ELF32_R_TYPE (rel->r_info);
 382       howto = elf_mn10200_howto_table + r_type;
 383
 384       h = NULL;
 385       sym = NULL;
 386       sec = NULL;
 387       if (r_symndx < symtab_hdr->sh_info)
 388         {
 389           sym = local_syms + r_symndx;
 390           sec = local_sections[r_symndx];
 391           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 392         }
 393       else
 394         {
 395           bfd_boolean unresolved_reloc, warned;
 396
 397           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 398                                    r_symndx, symtab_hdr, sym_hashes,
 399                                    h, sec, relocation,
 400                                    unresolved_reloc, warned);
 401         }
 402
 403       if (sec != NULL && elf_discarded_section (sec))
 404         {
 405           /* For relocs against symbols from removed linkonce sections,
 406              or sections discarded by a linker script, we just want the
 407              section contents zeroed.  Avoid any special processing.  */
 408           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
 409           rel->r_info = 0;
 410           rel->r_addend = 0;
 411           continue;
 412         }
 413
 414       if (info->relocatable)
 415         continue;
 416
 417       r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
 418                                            input_section,
 419                                            contents, rel->r_offset,
 420                                            relocation, rel->r_addend,
 421                                            info, sec, h == NULL);
 422
 423       if (r != bfd_reloc_ok)
 424         {
 425           const char *name;
 426           const char *msg = (const char *) 0;
 427
 428           if (h != NULL)
 429             name = h->root.root.string;
 430           else
 431             {
 432               name = (bfd_elf_string_from_elf_section
 433                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
 434               if (name == NULL || *name == '\0')
 435                 name = bfd_section_name (input_bfd, sec);
 436             }
 437
 438           switch (r)
 439             {
 440             case bfd_reloc_overflow:
 441               if (! ((*info->callbacks->reloc_overflow)
 442                      (info, (h ? &h->root : NULL), name, howto->name,
 443                       (bfd_vma) 0, input_bfd, input_section,
 444                       rel->r_offset)))
 445                 return FALSE;
 446               break;
 447
 448             case bfd_reloc_undefined:
 449               if (! ((*info->callbacks->undefined_symbol)
 450                      (info, name, input_bfd, input_section,
 451                       rel->r_offset, TRUE)))
 452                 return FALSE;
 453               break;
 454
 455             case bfd_reloc_outofrange:
 456               msg = _("internal error: out of range error");
 457               goto common_error;
 458
 459             case bfd_reloc_notsupported:
 460               msg = _("internal error: unsupported relocation error");
 461               goto common_error;
 462
 463             case bfd_reloc_dangerous:
 464               msg = _("internal error: dangerous error");
 465               goto common_error;
 466
 467             default:
 468               msg = _("internal error: unknown error");
 469               /* fall through */
 470
 471             common_error:
 472               if (!((*info->callbacks->warning)
 473                     (info, msg, name, input_bfd, input_section,
 474                      rel->r_offset)))
 475                 return FALSE;
 476               break;
 477             }
 478         }
 479     }
 480
 481   return TRUE;
 482 }
 483
 484 /* This function handles relaxing for the mn10200.
 485
 486    There are quite a few relaxing opportunities available on the mn10200:
 487
 488         * jsr:24 -> jsr:16                                         2 bytes
 489
 490         * jmp:24 -> jmp:16                                         2 bytes
 491         * jmp:16 -> bra:8                                          1 byte
 492
 493                 * If the previous instruction is a conditional branch
 494                 around the jump/bra, we may be able to reverse its condition
 495                 and change its target to the jump's target.  The jump/bra
 496                 can then be deleted.                               2 bytes
 497
 498         * mov abs24 -> mov abs16        2 byte savings
 499
 500         * Most instructions which accept imm24 can relax to imm16  2 bytes
 501         - Most instructions which accept imm16 can relax to imm8   1 byte
 502
 503         * Most instructions which accept d24 can relax to d16      2 bytes
 504         - Most instructions which accept d16 can relax to d8       1 byte
 505
 506         abs24, imm24, d24 all look the same at the reloc level.  It
 507         might make the code simpler if we had different relocs for
 508         the various relaxable operand types.
 509
 510         We don't handle imm16->imm8 or d16->d8 as they're very rare
 511         and somewhat more difficult to support.  */
 512
 513 static bfd_boolean
 514 mn10200_elf_relax_section (abfd, sec, link_info, again)
 515      bfd *abfd;
 516      asection *sec;
 517      struct bfd_link_info *link_info;
 518      bfd_boolean *again;
 519 {
 520   Elf_Internal_Shdr *symtab_hdr;
 521   Elf_Internal_Rela *internal_relocs;
 522   Elf_Internal_Rela *irel, *irelend;
 523   bfd_byte *contents = NULL;
 524   Elf_Internal_Sym *isymbuf = NULL;
 525
 526   /* Assume nothing changes.  */
 527   *again = FALSE;
 528
 529   /* We don't have to do anything for a relocatable link, if
 530      this section does not have relocs, or if this is not a
 531      code section.  */
 532   if (link_info->relocatable
 533       || (sec->flags & SEC_RELOC) == 0
 534       || sec->reloc_count == 0
 535       || (sec->flags & SEC_CODE) == 0)
 536     return TRUE;
 537
 538   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 539
 540   /* Get a copy of the native relocations.  */
 541   internal_relocs = (_bfd_elf_link_read_relocs
 542                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
 543                       link_info->keep_memory));
 544   if (internal_relocs == NULL)
 545     goto error_return;
 546
 547   /* Walk through them looking for relaxing opportunities.  */
 548   irelend = internal_relocs + sec->reloc_count;
 549   for (irel = internal_relocs; irel < irelend; irel++)
 550     {
 551       bfd_vma symval;
 552
 553       /* If this isn't something that can be relaxed, then ignore
 554          this reloc.  */
 555       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE
 556           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8
 557           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)
 558         continue;
 559
 560       /* Get the section contents if we haven't done so already.  */
 561       if (contents == NULL)
 562         {
 563           /* Get cached copy if it exists.  */
 564           if (elf_section_data (sec)->this_hdr.contents != NULL)
 565             contents = elf_section_data (sec)->this_hdr.contents;
 566           else
 567             {
 568               /* Go get them off disk.  */
 569               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
 570                 goto error_return;
 571             }
 572         }
 573
 574       /* Read this BFD's local symbols if we haven't done so already.  */
 575       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 576         {
 577           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 578           if (isymbuf == NULL)
 579             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 580                                             symtab_hdr->sh_info, 0,
 581                                             NULL, NULL, NULL);
 582           if (isymbuf == NULL)
 583             goto error_return;
 584         }
 585
 586       /* Get the value of the symbol referred to by the reloc.  */
 587       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 588         {
 589           /* A local symbol.  */
 590           Elf_Internal_Sym *isym;
 591           asection *sym_sec;
 592
 593           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 594           if (isym->st_shndx == SHN_UNDEF)
 595             sym_sec = bfd_und_section_ptr;
 596           else if (isym->st_shndx == SHN_ABS)
 597             sym_sec = bfd_abs_section_ptr;
 598           else if (isym->st_shndx == SHN_COMMON)
 599             sym_sec = bfd_com_section_ptr;
 600           else
 601             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 602           symval = (isym->st_value
 603                     + sym_sec->output_section->vma
 604                     + sym_sec->output_offset);
 605         }
 606       else
 607         {
 608           unsigned long indx;
 609           struct elf_link_hash_entry *h;
 610
 611           /* An external symbol.  */
 612           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 613           h = elf_sym_hashes (abfd)[indx];
 614           BFD_ASSERT (h != NULL);
 615           if (h->root.type != bfd_link_hash_defined
 616               && h->root.type != bfd_link_hash_defweak)
 617             {
 618               /* This appears to be a reference to an undefined
 619                  symbol.  Just ignore it--it will be caught by the
 620                  regular reloc processing.  */
 621               continue;
 622             }
 623
 624           symval = (h->root.u.def.value
 625                     + h->root.u.def.section->output_section->vma
 626                     + h->root.u.def.section->output_offset);
 627         }
 628
 629       /* For simplicity of coding, we are going to modify the section
 630          contents, the section relocs, and the BFD symbol table.  We
 631          must tell the rest of the code not to free up this
 632          information.  It would be possible to instead create a table
 633          of changes which have to be made, as is done in coff-mips.c;
 634          that would be more work, but would require less memory when
 635          the linker is run.  */
 636
 637       /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
 638          branch/call.  */
 639       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)
 640         {
 641           bfd_vma value = symval;
 642
 643           /* Deal with pc-relative gunk.  */
 644           value -= (sec->output_section->vma + sec->output_offset);
 645           value -= (irel->r_offset + 3);
 646           value += irel->r_addend;
 647
 648           /* See if the value will fit in 16 bits, note the high value is
 649              0x7fff + 2 as the target will be two bytes closer if we are
 650              able to relax.  */
 651           if ((long) value < 0x8001 && (long) value > -0x8000)
 652             {
 653               unsigned char code;
 654
 655               /* Get the opcode.  */
 656               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 657
 658               if (code != 0xe0 && code != 0xe1)
 659                 continue;
 660
 661               /* Note that we've changed the relocs, section contents, etc.  */
 662               elf_section_data (sec)->relocs = internal_relocs;
 663               elf_section_data (sec)->this_hdr.contents = contents;
 664               symtab_hdr->contents = (unsigned char *) isymbuf;
 665
 666               /* Fix the opcode.  */
 667               if (code == 0xe0)
 668                 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);
 669               else if (code == 0xe1)
 670                 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);
 671
 672               /* Fix the relocation's type.  */
 673               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 674                                            R_MN10200_PCREL16);
 675
 676               /* The opcode got shorter too, so we have to fix the offset.  */
 677               irel->r_offset -= 1;
 678
 679               /* Delete two bytes of data.  */
 680               if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 681                                                    irel->r_offset + 1, 2))
 682                 goto error_return;
 683
 684               /* That will change things, so, we should relax again.
 685                  Note that this is not required, and it may be slow.  */
 686               *again = TRUE;
 687             }
 688         }
 689
 690       /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
 691          branch.  */
 692       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16)
 693         {
 694           bfd_vma value = symval;
 695
 696           /* Deal with pc-relative gunk.  */
 697           value -= (sec->output_section->vma + sec->output_offset);
 698           value -= (irel->r_offset + 2);
 699           value += irel->r_addend;
 700
 701           /* See if the value will fit in 8 bits, note the high value is
 702              0x7f + 1 as the target will be one bytes closer if we are
 703              able to relax.  */
 704           if ((long) value < 0x80 && (long) value > -0x80)
 705             {
 706               unsigned char code;
 707
 708               /* Get the opcode.  */
 709               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 710
 711               if (code != 0xfc)
 712                 continue;
 713
 714               /* Note that we've changed the relocs, section contents, etc.  */
 715               elf_section_data (sec)->relocs = internal_relocs;
 716               elf_section_data (sec)->this_hdr.contents = contents;
 717               symtab_hdr->contents = (unsigned char *) isymbuf;
 718
 719               /* Fix the opcode.  */
 720               bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1);
 721
 722               /* Fix the relocation's type.  */
 723               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 724                                            R_MN10200_PCREL8);
 725
 726               /* Delete one byte of data.  */
 727               if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 728                                                    irel->r_offset + 1, 1))
 729                 goto error_return;
 730
 731               /* That will change things, so, we should relax again.
 732                  Note that this is not required, and it may be slow.  */
 733               *again = TRUE;
 734             }
 735         }
 736
 737       /* Try to eliminate an unconditional 8 bit pc-relative branch
 738          which immediately follows a conditional 8 bit pc-relative
 739          branch around the unconditional branch.
 740
 741             original:           new:
 742             bCC lab1            bCC' lab2
 743             bra lab2
 744            lab1:               lab1:
 745
 746          This happens when the bCC can't reach lab2 at assembly time,
 747          but due to other relaxations it can reach at link time.  */
 748       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8)
 749         {
 750           Elf_Internal_Rela *nrel;
 751           bfd_vma value = symval;
 752           unsigned char code;
 753
 754           /* Deal with pc-relative gunk.  */
 755           value -= (sec->output_section->vma + sec->output_offset);
 756           value -= (irel->r_offset + 1);
 757           value += irel->r_addend;
 758
 759           /* Do nothing if this reloc is the last byte in the section.  */
 760           if (irel->r_offset == sec->size)
 761             continue;
 762
 763           /* See if the next instruction is an unconditional pc-relative
 764              branch, more often than not this test will fail, so we
 765              test it first to speed things up.  */
 766           code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
 767           if (code != 0xea)
 768             continue;
 769
 770           /* Also make sure the next relocation applies to the next
 771              instruction and that it's a pc-relative 8 bit branch.  */
 772           nrel = irel + 1;
 773           if (nrel == irelend
 774               || irel->r_offset + 2 != nrel->r_offset
 775               || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8)
 776             continue;
 777
 778           /* Make sure our destination immediately follows the
 779              unconditional branch.  */
 780           if (symval != (sec->output_section->vma + sec->output_offset
 781                          + irel->r_offset + 3))
 782             continue;
 783
 784           /* Now make sure we are a conditional branch.  This may not
 785              be necessary, but why take the chance.
 786
 787              Note these checks assume that R_MN10200_PCREL8 relocs
 788              only occur on bCC and bCCx insns.  If they occured
 789              elsewhere, we'd need to know the start of this insn
 790              for this check to be accurate.  */
 791           code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 792           if (code != 0xe0 && code != 0xe1 && code != 0xe2
 793               && code != 0xe3 && code != 0xe4 && code != 0xe5
 794               && code != 0xe6 && code != 0xe7 && code != 0xe8
 795               && code != 0xe9 && code != 0xec && code != 0xed
 796               && code != 0xee && code != 0xef && code != 0xfc
 797               && code != 0xfd && code != 0xfe && code != 0xff)
 798             continue;
 799
 800           /* We also have to be sure there is no symbol/label
 801              at the unconditional branch.  */
 802           if (mn10200_elf_symbol_address_p (abfd, sec, isymbuf,
 803                                             irel->r_offset + 1))
 804             continue;
 805
 806           /* Note that we've changed the relocs, section contents, etc.  */
 807           elf_section_data (sec)->relocs = internal_relocs;
 808           elf_section_data (sec)->this_hdr.contents = contents;
 809           symtab_hdr->contents = (unsigned char *) isymbuf;
 810
 811           /* Reverse the condition of the first branch.  */
 812           switch (code)
 813             {
 814             case 0xfc:
 815               code = 0xfd;
 816               break;
 817             case 0xfd:
 818               code = 0xfc;
 819               break;
 820             case 0xfe:
 821               code = 0xff;
 822               break;
 823             case 0xff:
 824               code = 0xfe;
 825               break;
 826             case 0xe8:
 827               code = 0xe9;
 828               break;
 829             case 0xe9:
 830               code = 0xe8;
 831               break;
 832             case 0xe0:
 833               code = 0xe2;
 834               break;
 835             case 0xe2:
 836               code = 0xe0;
 837               break;
 838             case 0xe3:
 839               code = 0xe1;
 840               break;
 841             case 0xe1:
 842               code = 0xe3;
 843               break;
 844             case 0xe4:
 845               code = 0xe6;
 846               break;
 847             case 0xe6:
 848               code = 0xe4;
 849               break;
 850             case 0xe7:
 851               code = 0xe5;
 852               break;
 853             case 0xe5:
 854               code = 0xe7;
 855               break;
 856             case 0xec:
 857               code = 0xed;
 858               break;
 859             case 0xed:
 860               code = 0xec;
 861               break;
 862             case 0xee:
 863               code = 0xef;
 864               break;
 865             case 0xef:
 866               code = 0xee;
 867               break;
 868             }
 869           bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
 870
 871           /* Set the reloc type and symbol for the first branch
 872              from the second branch.  */
 873           irel->r_info = nrel->r_info;
 874
 875           /* Make the reloc for the second branch a null reloc.  */
 876           nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
 877                                        R_MN10200_NONE);
 878
 879           /* Delete two bytes of data.  */
 880           if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 881                                                irel->r_offset + 1, 2))
 882             goto error_return;
 883
 884           /* That will change things, so, we should relax again.
 885              Note that this is not required, and it may be slow.  */
 886           *again = TRUE;
 887         }
 888
 889       /* Try to turn a 24bit immediate, displacement or absolute address
 890          into a 16bit immediate, displacement or absolute address.  */
 891       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24)
 892         {
 893           bfd_vma value = symval;
 894
 895           /* See if the value will fit in 16 bits.
 896              We allow any 16bit match here.  We prune those we can't
 897              handle below.  */
 898           if ((long) value < 0x7fff && (long) value > -0x8000)
 899             {
 900               unsigned char code;
 901
 902               /* All insns which have 24bit operands are 5 bytes long,
 903                  the first byte will always be 0xf4, but we double check
 904                  it just in case.  */
 905
 906               /* Get the first opcode.  */
 907               code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
 908
 909               if (code != 0xf4)
 910                 continue;
 911
 912               /* Get the second opcode.  */
 913               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 914
 915               switch (code & 0xfc)
 916                 {
 917                 /* mov imm24,dn -> mov imm16,dn */
 918                 case 0x70:
 919                   /* Not safe if the high bit is on as relaxing may
 920                      move the value out of high mem and thus not fit
 921                      in a signed 16bit value.  */
 922                   if (value & 0x8000)
 923                     continue;
 924
 925                   /* Note that we've changed the relocation contents, etc.  */
 926                   elf_section_data (sec)->relocs = internal_relocs;
 927                   elf_section_data (sec)->this_hdr.contents = contents;
 928                   symtab_hdr->contents = (unsigned char *) isymbuf;
 929
 930                   /* Fix the opcode.  */
 931                   bfd_put_8 (abfd, 0xf8 + (code & 0x03),
 932                              contents + irel->r_offset - 2);
 933
 934                   /* Fix the relocation's type.  */
 935                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 936                                                R_MN10200_16);
 937
 938                   /* The opcode got shorter too, so we have to fix the
 939                      offset.  */
 940                   irel->r_offset -= 1;
 941
 942                   /* Delete two bytes of data.  */
 943                   if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 944                                                        irel->r_offset + 1, 2))
 945                     goto error_return;
 946
 947                   /* That will change things, so, we should relax again.
 948                      Note that this is not required, and it may be slow.  */
 949                   *again = TRUE;
 950                   break;
 951
 952                 /* mov imm24,an -> mov imm16,an
 953                    cmp imm24,an -> cmp imm16,an
 954                    mov (abs24),dn -> mov (abs16),dn
 955                    mov dn,(abs24) -> mov dn,(abs16)
 956                    movb dn,(abs24) -> movb dn,(abs16)
 957                    movbu (abs24),dn -> movbu (abs16),dn */
 958                 case 0x74:
 959                 case 0x7c:
 960                 case 0xc0:
 961                 case 0x40:
 962                 case 0x44:
 963                 case 0xc8:
 964                   /* Note that we've changed the relocation contents, etc.  */
 965                   elf_section_data (sec)->relocs = internal_relocs;
 966                   elf_section_data (sec)->this_hdr.contents = contents;
 967                   symtab_hdr->contents = (unsigned char *) isymbuf;
 968
 969                   if ((code & 0xfc) == 0x74)
 970                     code = 0xdc + (code & 0x03);
 971                   else if ((code & 0xfc) == 0x7c)
 972                     code = 0xec + (code & 0x03);
 973                   else if ((code & 0xfc) == 0xc0)
 974                     code = 0xc8 + (code & 0x03);
 975                   else if ((code & 0xfc) == 0x40)
 976                     code = 0xc0 + (code & 0x03);
 977                   else if ((code & 0xfc) == 0x44)
 978                     code = 0xc4 + (code & 0x03);
 979                   else if ((code & 0xfc) == 0xc8)
 980                     code = 0xcc + (code & 0x03);
 981
 982                   /* Fix the opcode.  */
 983                   bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
 984
 985                   /* Fix the relocation's type.  */
 986                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 987                                                R_MN10200_16);
 988
 989                   /* The opcode got shorter too, so we have to fix the
 990                      offset.  */
 991                   irel->r_offset -= 1;
 992
 993                   /* Delete two bytes of data.  */
 994                   if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 995                                                        irel->r_offset + 1, 2))
 996                     goto error_return;
 997
 998                   /* That will change things, so, we should relax again.
 999                      Note that this is not required, and it may be slow.  */
1000                   *again = TRUE;
1001                   break;
1002
1003                 /* cmp imm24,dn -> cmp imm16,dn
1004                    mov (abs24),an -> mov (abs16),an
1005                    mov an,(abs24) -> mov an,(abs16)
1006                    add imm24,dn -> add imm16,dn
1007                    add imm24,an -> add imm16,an
1008                    sub imm24,dn -> sub imm16,dn
1009                    sub imm24,an -> sub imm16,an
1010                    And all d24->d16 in memory ops.  */
1011                 case 0x78:
1012                 case 0xd0:
1013                 case 0x50:
1014                 case 0x60:
1015                 case 0x64:
1016                 case 0x68:
1017                 case 0x6c:
1018                 case 0x80:
1019                 case 0xf0:
1020                 case 0x00:
1021                 case 0x10:
1022                 case 0xb0:
1023                 case 0x30:
1024                 case 0xa0:
1025                 case 0x20:
1026                 case 0x90:
1027                   /* Not safe if the high bit is on as relaxing may
1028                      move the value out of high mem and thus not fit
1029                      in a signed 16bit value.  */
1030                   if (((code & 0xfc) == 0x78
1031                        || (code & 0xfc) == 0x60
1032                        || (code & 0xfc) == 0x64
1033                        || (code & 0xfc) == 0x68
1034                        || (code & 0xfc) == 0x6c
1035                        || (code & 0xfc) == 0x80
1036                        || (code & 0xfc) == 0xf0
1037                        || (code & 0xfc) == 0x00
1038                        || (code & 0xfc) == 0x10
1039                        || (code & 0xfc) == 0xb0
1040                        || (code & 0xfc) == 0x30
1041                        || (code & 0xfc) == 0xa0
1042                        || (code & 0xfc) == 0x20
1043                        || (code & 0xfc) == 0x90)
1044                       && (value & 0x8000) != 0)
1045                     continue;
1046
1047                   /* Note that we've changed the relocation contents, etc.  */
1048                   elf_section_data (sec)->relocs = internal_relocs;
1049                   elf_section_data (sec)->this_hdr.contents = contents;
1050                   symtab_hdr->contents = (unsigned char *) isymbuf;
1051
1052                   /* Fix the opcode.  */
1053                   bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2);
1054
1055                   if ((code & 0xfc) == 0x78)
1056                     code = 0x48 + (code & 0x03);
1057                   else if ((code & 0xfc) == 0xd0)
1058                     code = 0x30 + (code & 0x03);
1059                   else if ((code & 0xfc) == 0x50)
1060                     code = 0x20 + (code & 0x03);
1061                   else if ((code & 0xfc) == 0x60)
1062                     code = 0x18 + (code & 0x03);
1063                   else if ((code & 0xfc) == 0x64)
1064                     code = 0x08 + (code & 0x03);
1065                   else if ((code & 0xfc) == 0x68)
1066                     code = 0x1c + (code & 0x03);
1067                   else if ((code & 0xfc) == 0x6c)
1068                     code = 0x0c + (code & 0x03);
1069                   else if ((code & 0xfc) == 0x80)
1070                     code = 0xc0 + (code & 0x07);
1071                   else if ((code & 0xfc) == 0xf0)
1072                     code = 0xb0 + (code & 0x07);
1073                   else if ((code & 0xfc) == 0x00)
1074                     code = 0x80 + (code & 0x07);
1075                   else if ((code & 0xfc) == 0x10)
1076                     code = 0xa0 + (code & 0x07);
1077                   else if ((code & 0xfc) == 0xb0)
1078                     code = 0x70 + (code & 0x07);
1079                   else if ((code & 0xfc) == 0x30)
1080                     code = 0x60 + (code & 0x07);
1081                   else if ((code & 0xfc) == 0xa0)
1082                     code = 0xd0 + (code & 0x07);
1083                   else if ((code & 0xfc) == 0x20)
1084                     code = 0x90 + (code & 0x07);
1085                   else if ((code & 0xfc) == 0x90)
1086                     code = 0x50 + (code & 0x07);
1087
1088                   bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1089
1090                   /* Fix the relocation's type.  */
1091                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1092                                                R_MN10200_16);
1093
1094                   /* Delete one bytes of data.  */
1095                   if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1096                                                        irel->r_offset + 2, 1))
1097                     goto error_return;
1098
1099                   /* That will change things, so, we should relax again.
1100                      Note that this is not required, and it may be slow.  */
1101                   *again = TRUE;
1102                   break;
1103
1104                 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1105                 case 0xc4:
1106                   /* Note that we've changed the reldection contents, etc.  */
1107                   elf_section_data (sec)->relocs = internal_relocs;
1108                   elf_section_data (sec)->this_hdr.contents = contents;
1109                   symtab_hdr->contents = (unsigned char *) isymbuf;
1110
1111                   bfd_put_8 (abfd, 0xcc + (code & 0x03),
1112                              contents + irel->r_offset - 2);
1113
1114                   bfd_put_8 (abfd, 0xb8 + (code & 0x03),
1115                              contents + irel->r_offset - 1);
1116
1117                   /* Fix the relocation's type.  */
1118                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1119                                                R_MN10200_16);
1120
1121                   /* The reloc will be applied one byte in front of its
1122                      current location.  */
1123                   irel->r_offset -= 1;
1124
1125                   /* Delete one bytes of data.  */
1126                   if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1127                                                        irel->r_offset + 2, 1))
1128                     goto error_return;
1129
1130                   /* That will change things, so, we should relax again.
1131                      Note that this is not required, and it may be slow.  */
1132                   *again = TRUE;
1133                   break;
1134                 }
1135             }
1136         }
1137     }
1138
1139   if (isymbuf != NULL
1140       && symtab_hdr->contents != (unsigned char *) isymbuf)
1141     {
1142       if (! link_info->keep_memory)
1143         free (isymbuf);
1144       else
1145         {
1146           /* Cache the symbols for elf_link_input_bfd.  */
1147           symtab_hdr->contents = (unsigned char *) isymbuf;
1148         }
1149     }
1150
1151   if (contents != NULL
1152       && elf_section_data (sec)->this_hdr.contents != contents)
1153     {
1154       if (! link_info->keep_memory)
1155         free (contents);
1156       else
1157         {
1158           /* Cache the section contents for elf_link_input_bfd.  */
1159           elf_section_data (sec)->this_hdr.contents = contents;
1160         }
1161     }
1162
1163   if (internal_relocs != NULL
1164       && elf_section_data (sec)->relocs != internal_relocs)
1165     free (internal_relocs);
1166
1167   return TRUE;
1168
1169  error_return:
1170   if (isymbuf != NULL
1171       && symtab_hdr->contents != (unsigned char *) isymbuf)
1172     free (isymbuf);
1173   if (contents != NULL
1174       && elf_section_data (sec)->this_hdr.contents != contents)
1175     free (contents);
1176   if (internal_relocs != NULL
1177       && elf_section_data (sec)->relocs != internal_relocs)
1178     free (internal_relocs);
1179
1180   return FALSE;
1181 }
1182
1183 /* Delete some bytes from a section while relaxing.  */
1184
1185 static bfd_boolean
1186 mn10200_elf_relax_delete_bytes (abfd, sec, addr, count)
1187      bfd *abfd;
1188      asection *sec;
1189      bfd_vma addr;
1190      int count;
1191 {
1192   Elf_Internal_Shdr *symtab_hdr;
1193   unsigned int sec_shndx;
1194   bfd_byte *contents;
1195   Elf_Internal_Rela *irel, *irelend;
1196   Elf_Internal_Rela *irelalign;
1197   bfd_vma toaddr;
1198   Elf_Internal_Sym *isym;
1199   Elf_Internal_Sym *isymend;
1200   struct elf_link_hash_entry **sym_hashes;
1201   struct elf_link_hash_entry **end_hashes;
1202   unsigned int symcount;
1203
1204   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1205
1206   contents = elf_section_data (sec)->this_hdr.contents;
1207
1208   /* The deletion must stop at the next ALIGN reloc for an aligment
1209      power larger than the number of bytes we are deleting.  */
1210
1211   irelalign = NULL;
1212   toaddr = sec->size;
1213
1214   irel = elf_section_data (sec)->relocs;
1215   irelend = irel + sec->reloc_count;
1216
1217   /* Actually delete the bytes.  */
1218   memmove (contents + addr, contents + addr + count,
1219            (size_t) (toaddr - addr - count));
1220   sec->size -= count;
1221
1222   /* Adjust all the relocs.  */
1223   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1224     {
1225       /* Get the new reloc address.  */
1226       if ((irel->r_offset > addr
1227            && irel->r_offset < toaddr))
1228         irel->r_offset -= count;
1229     }
1230
1231   /* Adjust the local symbols defined in this section.  */
1232   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1233   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1234   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1235     {
1236       if (isym->st_shndx == sec_shndx
1237           && isym->st_value > addr
1238           && isym->st_value < toaddr)
1239         isym->st_value -= count;
1240     }
1241
1242   /* Now adjust the global symbols defined in this section.  */
1243   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1244               - symtab_hdr->sh_info);
1245   sym_hashes = elf_sym_hashes (abfd);
1246   end_hashes = sym_hashes + symcount;
1247   for (; sym_hashes < end_hashes; sym_hashes++)
1248     {
1249       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1250       if ((sym_hash->root.type == bfd_link_hash_defined
1251            || sym_hash->root.type == bfd_link_hash_defweak)
1252           && sym_hash->root.u.def.section == sec
1253           && sym_hash->root.u.def.value > addr
1254           && sym_hash->root.u.def.value < toaddr)
1255         {
1256           sym_hash->root.u.def.value -= count;
1257         }
1258     }
1259
1260   return TRUE;
1261 }
1262
1263 /* Return TRUE if a symbol exists at the given address, else return
1264    FALSE.  */
1265 static bfd_boolean
1266 mn10200_elf_symbol_address_p (abfd, sec, isym, addr)
1267      bfd *abfd;
1268      asection *sec;
1269      Elf_Internal_Sym *isym;
1270      bfd_vma addr;
1271 {
1272   Elf_Internal_Shdr *symtab_hdr;
1273   unsigned int sec_shndx;
1274   Elf_Internal_Sym *isymend;
1275   struct elf_link_hash_entry **sym_hashes;
1276   struct elf_link_hash_entry **end_hashes;
1277   unsigned int symcount;
1278
1279   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1280
1281   /* Examine all the local symbols.  */
1282   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1283   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1284     {
1285       if (isym->st_shndx == sec_shndx
1286           && isym->st_value == addr)
1287         return TRUE;
1288     }
1289
1290   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1291               - symtab_hdr->sh_info);
1292   sym_hashes = elf_sym_hashes (abfd);
1293   end_hashes = sym_hashes + symcount;
1294   for (; sym_hashes < end_hashes; sym_hashes++)
1295     {
1296       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1297       if ((sym_hash->root.type == bfd_link_hash_defined
1298            || sym_hash->root.type == bfd_link_hash_defweak)
1299           && sym_hash->root.u.def.section == sec
1300           && sym_hash->root.u.def.value == addr)
1301         return TRUE;
1302     }
1303
1304   return FALSE;
1305 }
1306
1307 /* This is a version of bfd_generic_get_relocated_section_contents
1308    which uses mn10200_elf_relocate_section.  */
1309
1310 static bfd_byte *
1311 mn10200_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1312                                             data, relocatable, symbols)
1313      bfd *output_bfd;
1314      struct bfd_link_info *link_info;
1315      struct bfd_link_order *link_order;
1316      bfd_byte *data;
1317      bfd_boolean relocatable;
1318      asymbol **symbols;
1319 {
1320   Elf_Internal_Shdr *symtab_hdr;
1321   asection *input_section = link_order->u.indirect.section;
1322   bfd *input_bfd = input_section->owner;
1323   asection **sections = NULL;
1324   Elf_Internal_Rela *internal_relocs = NULL;
1325   Elf_Internal_Sym *isymbuf = NULL;
1326
1327   /* We only need to handle the case of relaxing, or of having a
1328      particular set of section contents, specially.  */
1329   if (relocatable
1330       || elf_section_data (input_section)->this_hdr.contents == NULL)
1331     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1332                                                        link_order, data,
1333                                                        relocatable,
1334                                                        symbols);
1335
1336   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1337
1338   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1339           (size_t) input_section->size);
1340
1341   if ((input_section->flags & SEC_RELOC) != 0
1342       && input_section->reloc_count > 0)
1343     {
1344       Elf_Internal_Sym *isym;
1345       Elf_Internal_Sym *isymend;
1346       asection **secpp;
1347       bfd_size_type amt;
1348
1349       internal_relocs = (_bfd_elf_link_read_relocs
1350                          (input_bfd, input_section, (PTR) NULL,
1351                           (Elf_Internal_Rela *) NULL, FALSE));
1352       if (internal_relocs == NULL)
1353         goto error_return;
1354
1355       if (symtab_hdr->sh_info != 0)
1356         {
1357           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1358           if (isymbuf == NULL)
1359             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1360                                             symtab_hdr->sh_info, 0,
1361                                             NULL, NULL, NULL);
1362           if (isymbuf == NULL)
1363             goto error_return;
1364         }
1365
1366       amt = symtab_hdr->sh_info;
1367       amt *= sizeof (asection *);
1368       sections = (asection **) bfd_malloc (amt);
1369       if (sections == NULL && amt != 0)
1370         goto error_return;
1371
1372       isymend = isymbuf + symtab_hdr->sh_info;
1373       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1374         {
1375           asection *isec;
1376
1377           if (isym->st_shndx == SHN_UNDEF)
1378             isec = bfd_und_section_ptr;
1379           else if (isym->st_shndx == SHN_ABS)
1380             isec = bfd_abs_section_ptr;
1381           else if (isym->st_shndx == SHN_COMMON)
1382             isec = bfd_com_section_ptr;
1383           else
1384             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1385
1386           *secpp = isec;
1387         }
1388
1389       if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd,
1390                                      input_section, data, internal_relocs,
1391                                      isymbuf, sections))
1392         goto error_return;
1393
1394       if (sections != NULL)
1395         free (sections);
1396       if (isymbuf != NULL
1397           && symtab_hdr->contents != (unsigned char *) isymbuf)
1398         free (isymbuf);
1399       if (elf_section_data (input_section)->relocs != internal_relocs)
1400         free (internal_relocs);
1401     }
1402
1403   return data;
1404
1405  error_return:
1406   if (sections != NULL)
1407     free (sections);
1408   if (isymbuf != NULL
1409       && symtab_hdr->contents != (unsigned char *) isymbuf)
1410     free (isymbuf);
1411   if (internal_relocs != NULL
1412       && elf_section_data (input_section)->relocs != internal_relocs)
1413     free (internal_relocs);
1414   return NULL;
1415 }
1416
1417 #define TARGET_LITTLE_SYM       bfd_elf32_mn10200_vec
1418 #define TARGET_LITTLE_NAME      "elf32-mn10200"
1419 #define ELF_ARCH                bfd_arch_mn10200
1420 #define ELF_MACHINE_CODE        EM_MN10200
1421 #define ELF_MACHINE_ALT1        EM_CYGNUS_MN10200
1422 #define ELF_MAXPAGESIZE         0x1000
1423
1424 #define elf_backend_rela_normal 1
1425 #define elf_info_to_howto       mn10200_info_to_howto
1426 #define elf_info_to_howto_rel   0
1427 #define elf_backend_relocate_section mn10200_elf_relocate_section
1428 #define bfd_elf32_bfd_relax_section     mn10200_elf_relax_section
1429 #define bfd_elf32_bfd_get_relocated_section_contents \
1430                                 mn10200_elf_get_relocated_section_contents
1431
1432 #define elf_symbol_leading_char '_'
1433
1434 #include "elf32-target.h"