bfd/elf-m10200.c

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