bfd/elf-m10200.c

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