bfd/elf-m10200.c

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