bfd/elf-m10200.c

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