bfd/elf-m10200.c

   1 /* Matsushita 10200 specific support for 32-bit ELF
   2    Copyright (C) 1996-2023 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          0,
  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          4,
  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          2,
  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          1,
  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          4,
 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          1,
 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          2,
 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          4,
 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->reloc_count == 0
 581       || (sec->flags & SEC_RELOC) == 0
 582       || (sec->flags & SEC_HAS_CONTENTS) == 0
 583       || (sec->flags & SEC_CODE) == 0)
 584     return true;
 585
 586   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 587
 588   /* Get a copy of the native relocations.  */
 589   internal_relocs = (_bfd_elf_link_read_relocs
 590                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
 591                       link_info->keep_memory));
 592   if (internal_relocs == NULL)
 593     goto error_return;
 594
 595   /* Walk through them looking for relaxing opportunities.  */
 596   irelend = internal_relocs + sec->reloc_count;
 597   for (irel = internal_relocs; irel < irelend; irel++)
 598     {
 599       bfd_vma symval;
 600
 601       /* If this isn't something that can be relaxed, then ignore
 602          this reloc.  */
 603       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE
 604           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8
 605           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)
 606         continue;
 607
 608       /* Get the section contents if we haven't done so already.  */
 609       if (contents == NULL)
 610         {
 611           /* Get cached copy if it exists.  */
 612           if (elf_section_data (sec)->this_hdr.contents != NULL)
 613             contents = elf_section_data (sec)->this_hdr.contents;
 614           else
 615             {
 616               /* Go get them off disk.  */
 617               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
 618                 goto error_return;
 619             }
 620         }
 621
 622       /* Read this BFD's local symbols if we haven't done so already.  */
 623       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 624         {
 625           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 626           if (isymbuf == NULL)
 627             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 628                                             symtab_hdr->sh_info, 0,
 629                                             NULL, NULL, NULL);
 630           if (isymbuf == NULL)
 631             goto error_return;
 632         }
 633
 634       /* Get the value of the symbol referred to by the reloc.  */
 635       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 636         {
 637           /* A local symbol.  */
 638           Elf_Internal_Sym *isym;
 639           asection *sym_sec;
 640
 641           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 642           if (isym->st_shndx == SHN_UNDEF)
 643             sym_sec = bfd_und_section_ptr;
 644           else if (isym->st_shndx == SHN_ABS)
 645             sym_sec = bfd_abs_section_ptr;
 646           else if (isym->st_shndx == SHN_COMMON)
 647             sym_sec = bfd_com_section_ptr;
 648           else
 649             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 650           symval = (isym->st_value
 651                     + sym_sec->output_section->vma
 652                     + sym_sec->output_offset);
 653         }
 654       else
 655         {
 656           unsigned long indx;
 657           struct elf_link_hash_entry *h;
 658
 659           /* An external symbol.  */
 660           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 661           h = elf_sym_hashes (abfd)[indx];
 662           BFD_ASSERT (h != NULL);
 663           if (h->root.type != bfd_link_hash_defined
 664               && h->root.type != bfd_link_hash_defweak)
 665             {
 666               /* This appears to be a reference to an undefined
 667                  symbol.  Just ignore it--it will be caught by the
 668                  regular reloc processing.  */
 669               continue;
 670             }
 671
 672           symval = (h->root.u.def.value
 673                     + h->root.u.def.section->output_section->vma
 674                     + h->root.u.def.section->output_offset);
 675         }
 676
 677       /* For simplicity of coding, we are going to modify the section
 678          contents, the section relocs, and the BFD symbol table.  We
 679          must tell the rest of the code not to free up this
 680          information.  It would be possible to instead create a table
 681          of changes which have to be made, as is done in coff-mips.c;
 682          that would be more work, but would require less memory when
 683          the linker is run.  */
 684
 685       /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
 686          branch/call.  */
 687       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)
 688         {
 689           bfd_vma value = symval;
 690
 691           /* Deal with pc-relative gunk.  */
 692           value -= (sec->output_section->vma + sec->output_offset);
 693           value -= (irel->r_offset + 3);
 694           value += irel->r_addend;
 695
 696           /* See if the value will fit in 16 bits, note the high value is
 697              0x7fff + 2 as the target will be two bytes closer if we are
 698              able to relax.  */
 699           if ((long) value < 0x8001 && (long) value > -0x8000)
 700             {
 701               unsigned char code;
 702
 703               /* Get the opcode.  */
 704               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 705
 706               if (code != 0xe0 && code != 0xe1)
 707                 continue;
 708
 709               /* Note that we've changed the relocs, section contents, etc.  */
 710               elf_section_data (sec)->relocs = internal_relocs;
 711               elf_section_data (sec)->this_hdr.contents = contents;
 712               symtab_hdr->contents = (unsigned char *) isymbuf;
 713
 714               /* Fix the opcode.  */
 715               if (code == 0xe0)
 716                 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);
 717               else if (code == 0xe1)
 718                 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);
 719
 720               /* Fix the relocation's type.  */
 721               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 722                                            R_MN10200_PCREL16);
 723
 724               /* The opcode got shorter too, so we have to fix the offset.  */
 725               irel->r_offset -= 1;
 726
 727               /* Delete two bytes of data.  */
 728               if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 729                                                    irel->r_offset + 1, 2))
 730                 goto error_return;
 731
 732               /* That will change things, so, we should relax again.
 733                  Note that this is not required, and it may be slow.  */
 734               *again = true;
 735             }
 736         }
 737
 738       /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
 739          branch.  */
 740       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16)
 741         {
 742           bfd_vma value = symval;
 743
 744           /* Deal with pc-relative gunk.  */
 745           value -= (sec->output_section->vma + sec->output_offset);
 746           value -= (irel->r_offset + 2);
 747           value += irel->r_addend;
 748
 749           /* See if the value will fit in 8 bits, note the high value is
 750              0x7f + 1 as the target will be one bytes closer if we are
 751              able to relax.  */
 752           if ((long) value < 0x80 && (long) value > -0x80)
 753             {
 754               unsigned char code;
 755
 756               /* Get the opcode.  */
 757               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 758
 759               if (code != 0xfc)
 760                 continue;
 761
 762               /* Note that we've changed the relocs, section contents, etc.  */
 763               elf_section_data (sec)->relocs = internal_relocs;
 764               elf_section_data (sec)->this_hdr.contents = contents;
 765               symtab_hdr->contents = (unsigned char *) isymbuf;
 766
 767               /* Fix the opcode.  */
 768               bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1);
 769
 770               /* Fix the relocation's type.  */
 771               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 772                                            R_MN10200_PCREL8);
 773
 774               /* Delete one byte of data.  */
 775               if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 776                                                    irel->r_offset + 1, 1))
 777                 goto error_return;
 778
 779               /* That will change things, so, we should relax again.
 780                  Note that this is not required, and it may be slow.  */
 781               *again = true;
 782             }
 783         }
 784
 785       /* Try to eliminate an unconditional 8 bit pc-relative branch
 786          which immediately follows a conditional 8 bit pc-relative
 787          branch around the unconditional branch.
 788
 789             original:           new:
 790             bCC lab1            bCC' lab2
 791             bra lab2
 792            lab1:               lab1:
 793
 794          This happens when the bCC can't reach lab2 at assembly time,
 795          but due to other relaxations it can reach at link time.  */
 796       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8)
 797         {
 798           Elf_Internal_Rela *nrel;
 799           unsigned char code;
 800
 801           /* Do nothing if this reloc is the last byte in the section.  */
 802           if (irel->r_offset == sec->size)
 803             continue;
 804
 805           /* See if the next instruction is an unconditional pc-relative
 806              branch, more often than not this test will fail, so we
 807              test it first to speed things up.  */
 808           code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
 809           if (code != 0xea)
 810             continue;
 811
 812           /* Also make sure the next relocation applies to the next
 813              instruction and that it's a pc-relative 8 bit branch.  */
 814           nrel = irel + 1;
 815           if (nrel == irelend
 816               || irel->r_offset + 2 != nrel->r_offset
 817               || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8)
 818             continue;
 819
 820           /* Make sure our destination immediately follows the
 821              unconditional branch.  */
 822           if (symval != (sec->output_section->vma + sec->output_offset
 823                          + irel->r_offset + 3))
 824             continue;
 825
 826           /* Now make sure we are a conditional branch.  This may not
 827              be necessary, but why take the chance.
 828
 829              Note these checks assume that R_MN10200_PCREL8 relocs
 830              only occur on bCC and bCCx insns.  If they occured
 831              elsewhere, we'd need to know the start of this insn
 832              for this check to be accurate.  */
 833           code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 834           if (code != 0xe0 && code != 0xe1 && code != 0xe2
 835               && code != 0xe3 && code != 0xe4 && code != 0xe5
 836               && code != 0xe6 && code != 0xe7 && code != 0xe8
 837               && code != 0xe9 && code != 0xec && code != 0xed
 838               && code != 0xee && code != 0xef && code != 0xfc
 839               && code != 0xfd && code != 0xfe && code != 0xff)
 840             continue;
 841
 842           /* We also have to be sure there is no symbol/label
 843              at the unconditional branch.  */
 844           if (mn10200_elf_symbol_address_p (abfd, sec, isymbuf,
 845                                             irel->r_offset + 1))
 846             continue;
 847
 848           /* Note that we've changed the relocs, section contents, etc.  */
 849           elf_section_data (sec)->relocs = internal_relocs;
 850           elf_section_data (sec)->this_hdr.contents = contents;
 851           symtab_hdr->contents = (unsigned char *) isymbuf;
 852
 853           /* Reverse the condition of the first branch.  */
 854           switch (code)
 855             {
 856             case 0xfc:
 857               code = 0xfd;
 858               break;
 859             case 0xfd:
 860               code = 0xfc;
 861               break;
 862             case 0xfe:
 863               code = 0xff;
 864               break;
 865             case 0xff:
 866               code = 0xfe;
 867               break;
 868             case 0xe8:
 869               code = 0xe9;
 870               break;
 871             case 0xe9:
 872               code = 0xe8;
 873               break;
 874             case 0xe0:
 875               code = 0xe2;
 876               break;
 877             case 0xe2:
 878               code = 0xe0;
 879               break;
 880             case 0xe3:
 881               code = 0xe1;
 882               break;
 883             case 0xe1:
 884               code = 0xe3;
 885               break;
 886             case 0xe4:
 887               code = 0xe6;
 888               break;
 889             case 0xe6:
 890               code = 0xe4;
 891               break;
 892             case 0xe7:
 893               code = 0xe5;
 894               break;
 895             case 0xe5:
 896               code = 0xe7;
 897               break;
 898             case 0xec:
 899               code = 0xed;
 900               break;
 901             case 0xed:
 902               code = 0xec;
 903               break;
 904             case 0xee:
 905               code = 0xef;
 906               break;
 907             case 0xef:
 908               code = 0xee;
 909               break;
 910             }
 911           bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
 912
 913           /* Set the reloc type and symbol for the first branch
 914              from the second branch.  */
 915           irel->r_info = nrel->r_info;
 916
 917           /* Make the reloc for the second branch a null reloc.  */
 918           nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
 919                                        R_MN10200_NONE);
 920
 921           /* Delete two bytes of data.  */
 922           if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 923                                                irel->r_offset + 1, 2))
 924             goto error_return;
 925
 926           /* That will change things, so, we should relax again.
 927              Note that this is not required, and it may be slow.  */
 928           *again = true;
 929         }
 930
 931       /* Try to turn a 24bit immediate, displacement or absolute address
 932          into a 16bit immediate, displacement or absolute address.  */
 933       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24)
 934         {
 935           bfd_vma value = symval;
 936
 937           /* See if the value will fit in 16 bits.
 938              We allow any 16bit match here.  We prune those we can't
 939              handle below.  */
 940           if ((long) value < 0x7fff && (long) value > -0x8000)
 941             {
 942               unsigned char code;
 943
 944               /* All insns which have 24bit operands are 5 bytes long,
 945                  the first byte will always be 0xf4, but we double check
 946                  it just in case.  */
 947
 948               /* Get the first opcode.  */
 949               code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
 950
 951               if (code != 0xf4)
 952                 continue;
 953
 954               /* Get the second opcode.  */
 955               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 956
 957               switch (code & 0xfc)
 958                 {
 959                 /* mov imm24,dn -> mov imm16,dn */
 960                 case 0x70:
 961                   /* Not safe if the high bit is on as relaxing may
 962                      move the value out of high mem and thus not fit
 963                      in a signed 16bit value.  */
 964                   if (value & 0x8000)
 965                     continue;
 966
 967                   /* Note that we've changed the relocation contents, etc.  */
 968                   elf_section_data (sec)->relocs = internal_relocs;
 969                   elf_section_data (sec)->this_hdr.contents = contents;
 970                   symtab_hdr->contents = (unsigned char *) isymbuf;
 971
 972                   /* Fix the opcode.  */
 973                   bfd_put_8 (abfd, 0xf8 + (code & 0x03),
 974                              contents + irel->r_offset - 2);
 975
 976                   /* Fix the relocation's type.  */
 977                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 978                                                R_MN10200_16);
 979
 980                   /* The opcode got shorter too, so we have to fix the
 981                      offset.  */
 982                   irel->r_offset -= 1;
 983
 984                   /* Delete two bytes of data.  */
 985                   if (!mn10200_elf_relax_delete_bytes (abfd, sec,
 986                                                        irel->r_offset + 1, 2))
 987                     goto error_return;
 988
 989                   /* That will change things, so, we should relax again.
 990                      Note that this is not required, and it may be slow.  */
 991                   *again = true;
 992                   break;
 993
 994                 /* mov imm24,an -> mov imm16,an
 995                    cmp imm24,an -> cmp imm16,an
 996                    mov (abs24),dn -> mov (abs16),dn
 997                    mov dn,(abs24) -> mov dn,(abs16)
 998                    movb dn,(abs24) -> movb dn,(abs16)
 999                    movbu (abs24),dn -> movbu (abs16),dn */
1000                 case 0x74:
1001                 case 0x7c:
1002                 case 0xc0:
1003                 case 0x40:
1004                 case 0x44:
1005                 case 0xc8:
1006                   /* Note that we've changed the relocation contents, etc.  */
1007                   elf_section_data (sec)->relocs = internal_relocs;
1008                   elf_section_data (sec)->this_hdr.contents = contents;
1009                   symtab_hdr->contents = (unsigned char *) isymbuf;
1010
1011                   if ((code & 0xfc) == 0x74)
1012                     code = 0xdc + (code & 0x03);
1013                   else if ((code & 0xfc) == 0x7c)
1014                     code = 0xec + (code & 0x03);
1015                   else if ((code & 0xfc) == 0xc0)
1016                     code = 0xc8 + (code & 0x03);
1017                   else if ((code & 0xfc) == 0x40)
1018                     code = 0xc0 + (code & 0x03);
1019                   else if ((code & 0xfc) == 0x44)
1020                     code = 0xc4 + (code & 0x03);
1021                   else if ((code & 0xfc) == 0xc8)
1022                     code = 0xcc + (code & 0x03);
1023
1024                   /* Fix the opcode.  */
1025                   bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1026
1027                   /* Fix the relocation's type.  */
1028                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1029                                                R_MN10200_16);
1030
1031                   /* The opcode got shorter too, so we have to fix the
1032                      offset.  */
1033                   irel->r_offset -= 1;
1034
1035                   /* Delete two bytes of data.  */
1036                   if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1037                                                        irel->r_offset + 1, 2))
1038                     goto error_return;
1039
1040                   /* That will change things, so, we should relax again.
1041                      Note that this is not required, and it may be slow.  */
1042                   *again = true;
1043                   break;
1044
1045                 /* cmp imm24,dn -> cmp imm16,dn
1046                    mov (abs24),an -> mov (abs16),an
1047                    mov an,(abs24) -> mov an,(abs16)
1048                    add imm24,dn -> add imm16,dn
1049                    add imm24,an -> add imm16,an
1050                    sub imm24,dn -> sub imm16,dn
1051                    sub imm24,an -> sub imm16,an
1052                    And all d24->d16 in memory ops.  */
1053                 case 0x78:
1054                 case 0xd0:
1055                 case 0x50:
1056                 case 0x60:
1057                 case 0x64:
1058                 case 0x68:
1059                 case 0x6c:
1060                 case 0x80:
1061                 case 0xf0:
1062                 case 0x00:
1063                 case 0x10:
1064                 case 0xb0:
1065                 case 0x30:
1066                 case 0xa0:
1067                 case 0x20:
1068                 case 0x90:
1069                   /* Not safe if the high bit is on as relaxing may
1070                      move the value out of high mem and thus not fit
1071                      in a signed 16bit value.  */
1072                   if (((code & 0xfc) == 0x78
1073                        || (code & 0xfc) == 0x60
1074                        || (code & 0xfc) == 0x64
1075                        || (code & 0xfc) == 0x68
1076                        || (code & 0xfc) == 0x6c
1077                        || (code & 0xfc) == 0x80
1078                        || (code & 0xfc) == 0xf0
1079                        || (code & 0xfc) == 0x00
1080                        || (code & 0xfc) == 0x10
1081                        || (code & 0xfc) == 0xb0
1082                        || (code & 0xfc) == 0x30
1083                        || (code & 0xfc) == 0xa0
1084                        || (code & 0xfc) == 0x20
1085                        || (code & 0xfc) == 0x90)
1086                       && (value & 0x8000) != 0)
1087                     continue;
1088
1089                   /* Note that we've changed the relocation contents, etc.  */
1090                   elf_section_data (sec)->relocs = internal_relocs;
1091                   elf_section_data (sec)->this_hdr.contents = contents;
1092                   symtab_hdr->contents = (unsigned char *) isymbuf;
1093
1094                   /* Fix the opcode.  */
1095                   bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2);
1096
1097                   if ((code & 0xfc) == 0x78)
1098                     code = 0x48 + (code & 0x03);
1099                   else if ((code & 0xfc) == 0xd0)
1100                     code = 0x30 + (code & 0x03);
1101                   else if ((code & 0xfc) == 0x50)
1102                     code = 0x20 + (code & 0x03);
1103                   else if ((code & 0xfc) == 0x60)
1104                     code = 0x18 + (code & 0x03);
1105                   else if ((code & 0xfc) == 0x64)
1106                     code = 0x08 + (code & 0x03);
1107                   else if ((code & 0xfc) == 0x68)
1108                     code = 0x1c + (code & 0x03);
1109                   else if ((code & 0xfc) == 0x6c)
1110                     code = 0x0c + (code & 0x03);
1111                   else if ((code & 0xfc) == 0x80)
1112                     code = 0xc0 + (code & 0x07);
1113                   else if ((code & 0xfc) == 0xf0)
1114                     code = 0xb0 + (code & 0x07);
1115                   else if ((code & 0xfc) == 0x00)
1116                     code = 0x80 + (code & 0x07);
1117                   else if ((code & 0xfc) == 0x10)
1118                     code = 0xa0 + (code & 0x07);
1119                   else if ((code & 0xfc) == 0xb0)
1120                     code = 0x70 + (code & 0x07);
1121                   else if ((code & 0xfc) == 0x30)
1122                     code = 0x60 + (code & 0x07);
1123                   else if ((code & 0xfc) == 0xa0)
1124                     code = 0xd0 + (code & 0x07);
1125                   else if ((code & 0xfc) == 0x20)
1126                     code = 0x90 + (code & 0x07);
1127                   else if ((code & 0xfc) == 0x90)
1128                     code = 0x50 + (code & 0x07);
1129
1130                   bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1131
1132                   /* Fix the relocation's type.  */
1133                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1134                                                R_MN10200_16);
1135
1136                   /* Delete one bytes of data.  */
1137                   if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1138                                                        irel->r_offset + 2, 1))
1139                     goto error_return;
1140
1141                   /* That will change things, so, we should relax again.
1142                      Note that this is not required, and it may be slow.  */
1143                   *again = true;
1144                   break;
1145
1146                 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1147                 case 0xc4:
1148                   /* Note that we've changed the reldection contents, etc.  */
1149                   elf_section_data (sec)->relocs = internal_relocs;
1150                   elf_section_data (sec)->this_hdr.contents = contents;
1151                   symtab_hdr->contents = (unsigned char *) isymbuf;
1152
1153                   bfd_put_8 (abfd, 0xcc + (code & 0x03),
1154                              contents + irel->r_offset - 2);
1155
1156                   bfd_put_8 (abfd, 0xb8 + (code & 0x03),
1157                              contents + irel->r_offset - 1);
1158
1159                   /* Fix the relocation's type.  */
1160                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1161                                                R_MN10200_16);
1162
1163                   /* The reloc will be applied one byte in front of its
1164                      current location.  */
1165                   irel->r_offset -= 1;
1166
1167                   /* Delete one bytes of data.  */
1168                   if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1169                                                        irel->r_offset + 2, 1))
1170                     goto error_return;
1171
1172                   /* That will change things, so, we should relax again.
1173                      Note that this is not required, and it may be slow.  */
1174                   *again = true;
1175                   break;
1176                 }
1177             }
1178         }
1179     }
1180
1181   if (isymbuf != NULL
1182       && symtab_hdr->contents != (unsigned char *) isymbuf)
1183     {
1184       if (! link_info->keep_memory)
1185         free (isymbuf);
1186       else
1187         {
1188           /* Cache the symbols for elf_link_input_bfd.  */
1189           symtab_hdr->contents = (unsigned char *) isymbuf;
1190         }
1191     }
1192
1193   if (contents != NULL
1194       && elf_section_data (sec)->this_hdr.contents != contents)
1195     {
1196       if (! link_info->keep_memory)
1197         free (contents);
1198       else
1199         {
1200           /* Cache the section contents for elf_link_input_bfd.  */
1201           elf_section_data (sec)->this_hdr.contents = contents;
1202         }
1203     }
1204
1205   if (elf_section_data (sec)->relocs != internal_relocs)
1206     free (internal_relocs);
1207
1208   return true;
1209
1210  error_return:
1211   if (symtab_hdr->contents != (unsigned char *) isymbuf)
1212     free (isymbuf);
1213   if (elf_section_data (sec)->this_hdr.contents != contents)
1214     free (contents);
1215   if (elf_section_data (sec)->relocs != internal_relocs)
1216     free (internal_relocs);
1217
1218   return false;
1219 }
1220
1221 /* Return TRUE if a symbol exists at the given address, else return
1222    FALSE.  */
1223 static bool
1224 mn10200_elf_symbol_address_p (bfd *abfd,
1225                               asection *sec,
1226                               Elf_Internal_Sym *isym,
1227                               bfd_vma addr)
1228 {
1229   Elf_Internal_Shdr *symtab_hdr;
1230   unsigned int sec_shndx;
1231   Elf_Internal_Sym *isymend;
1232   struct elf_link_hash_entry **sym_hashes;
1233   struct elf_link_hash_entry **end_hashes;
1234   unsigned int symcount;
1235
1236   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1237
1238   /* Examine all the local symbols.  */
1239   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1240   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1241     {
1242       if (isym->st_shndx == sec_shndx
1243           && isym->st_value == addr)
1244         return true;
1245     }
1246
1247   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1248               - symtab_hdr->sh_info);
1249   sym_hashes = elf_sym_hashes (abfd);
1250   end_hashes = sym_hashes + symcount;
1251   for (; sym_hashes < end_hashes; sym_hashes++)
1252     {
1253       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1254       if ((sym_hash->root.type == bfd_link_hash_defined
1255            || sym_hash->root.type == bfd_link_hash_defweak)
1256           && sym_hash->root.u.def.section == sec
1257           && sym_hash->root.u.def.value == addr)
1258         return true;
1259     }
1260
1261   return false;
1262 }
1263
1264 /* This is a version of bfd_generic_get_relocated_section_contents
1265    which uses mn10200_elf_relocate_section.  */
1266
1267 static bfd_byte *
1268 mn10200_elf_get_relocated_section_contents (bfd *output_bfd,
1269                                             struct bfd_link_info *link_info,
1270                                             struct bfd_link_order *link_order,
1271                                             bfd_byte *data,
1272                                             bool relocatable,
1273                                             asymbol **symbols)
1274 {
1275   Elf_Internal_Shdr *symtab_hdr;
1276   asection *input_section = link_order->u.indirect.section;
1277   bfd *input_bfd = input_section->owner;
1278   asection **sections = NULL;
1279   Elf_Internal_Rela *internal_relocs = NULL;
1280   Elf_Internal_Sym *isymbuf = NULL;
1281
1282   /* We only need to handle the case of relaxing, or of having a
1283      particular set of section contents, specially.  */
1284   if (relocatable
1285       || elf_section_data (input_section)->this_hdr.contents == NULL)
1286     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1287                                                        link_order, data,
1288                                                        relocatable,
1289                                                        symbols);
1290
1291   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1292
1293   bfd_byte *orig_data = data;
1294   if (data == NULL)
1295     {
1296       data = bfd_malloc (input_section->size);
1297       if (data == NULL)
1298         return NULL;
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       free (sections);
1357       if (symtab_hdr->contents != (unsigned char *) isymbuf)
1358         free (isymbuf);
1359       if (elf_section_data (input_section)->relocs != internal_relocs)
1360         free (internal_relocs);
1361     }
1362
1363   return data;
1364
1365  error_return:
1366   free (sections);
1367   if (symtab_hdr->contents != (unsigned char *) isymbuf)
1368     free (isymbuf);
1369   if (elf_section_data (input_section)->relocs != internal_relocs)
1370     free (internal_relocs);
1371   if (orig_data == NULL)
1372     free (data);
1373   return NULL;
1374 }
1375
1376 #define TARGET_LITTLE_SYM       mn10200_elf32_vec
1377 #define TARGET_LITTLE_NAME      "elf32-mn10200"
1378 #define ELF_ARCH                bfd_arch_mn10200
1379 #define ELF_MACHINE_CODE        EM_MN10200
1380 #define ELF_MACHINE_ALT1        EM_CYGNUS_MN10200
1381 #define ELF_MAXPAGESIZE         0x1000
1382
1383 #define elf_backend_rela_normal 1
1384 #define elf_info_to_howto       mn10200_info_to_howto
1385 #define elf_info_to_howto_rel   NULL
1386 #define elf_backend_relocate_section mn10200_elf_relocate_section
1387 #define bfd_elf32_bfd_relax_section     mn10200_elf_relax_section
1388 #define bfd_elf32_bfd_get_relocated_section_contents \
1389                                 mn10200_elf_get_relocated_section_contents
1390
1391 #define elf_symbol_leading_char '_'
1392
1393 #include "elf32-target.h"