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