bfd/elf-m10200.c

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