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