bfd/elf-m10200.c

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