bfd/elf-m10300.c

   1 /* Matsushita 10300 specific support for 32-bit ELF
   2    Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
   3
   4 This file is part of BFD, the Binary File Descriptor library.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libbfd.h"
  23 #include "elf-bfd.h"
  24 #include "elf/mn10300.h"
  25
  26 struct elf32_mn10300_link_hash_entry
  27 {
  28   /* The basic elf link hash table entry.  */
  29   struct elf_link_hash_entry root;
  30
  31   /* For function symbols, the number of times this function is
  32      called directly (ie by name).  */
  33   unsigned int direct_calls;
  34
  35   /* For function symbols, the size of this function's stack
  36      (if <= 255 bytes).  We stuff this into "call" instructions
  37      to this target when it's valid and profitable to do so.
  38
  39      This does not include stack allocated by movm!  */
  40   unsigned char stack_size;
  41
  42   /* For function symbols, arguments (if any) for movm instruction
  43      in the prologue.  We stuff this value into "call" instructions
  44      to the target when it's valid and profitable to do so.  */
  45   unsigned char movm_args;
  46
  47   /* For funtion symbols, the amount of stack space that would be allocated
  48      by the movm instruction.  This is redundant with movm_args, but we
  49      add it to the hash table to avoid computing it over and over.  */
  50   unsigned char movm_stack_size;
  51
  52 /* When set, convert all "call" instructions to this target into "calls"
  53    instructions.  */
  54 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
  55
  56 /* Used to mark functions which have had redundant parts of their
  57    prologue deleted.  */
  58 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
  59   unsigned char flags;
  60 };
  61
  62 /* We derive a hash table from the main elf linker hash table so
  63    we can store state variables and a secondary hash table without
  64    resorting to global variables.  */
  65 struct elf32_mn10300_link_hash_table
  66 {
  67   /* The main hash table.  */
  68   struct elf_link_hash_table root;
  69
  70   /* A hash table for static functions.  We could derive a new hash table
  71      instead of using the full elf32_mn10300_link_hash_table if we wanted
  72      to save some memory.  */
  73   struct elf32_mn10300_link_hash_table *static_hash_table;
  74
  75   /* Random linker state flags.  */
  76 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
  77   char flags;
  78 };
  79
  80 /* For MN10300 linker hash table.  */
  81
  82 /* Get the MN10300 ELF linker hash table from a link_info structure.  */
  83
  84 #define elf32_mn10300_hash_table(p) \
  85   ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
  86
  87 #define elf32_mn10300_link_hash_traverse(table, func, info)             \
  88   (elf_link_hash_traverse                                               \
  89    (&(table)->root,                                                     \
  90     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
  91     (info)))
  92
  93 static struct bfd_hash_entry *elf32_mn10300_link_hash_newfunc
  94   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  95 static struct bfd_link_hash_table *elf32_mn10300_link_hash_table_create
  96   PARAMS ((bfd *));
  97
  98 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  99   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
 100 static void mn10300_info_to_howto
 101   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
 102 static boolean mn10300_elf_check_relocs
 103   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 104            const Elf_Internal_Rela *));
 105 static asection *mn10300_elf_gc_mark_hook
 106   PARAMS ((bfd *, struct bfd_link_info *info, Elf_Internal_Rela *,
 107            struct elf_link_hash_entry *, Elf_Internal_Sym *));
 108 static boolean mn10300_elf_relax_delete_bytes
 109   PARAMS ((bfd *, asection *, bfd_vma, int));
 110 static boolean mn10300_elf_symbol_address_p
 111   PARAMS ((bfd *, asection *, Elf32_External_Sym *, bfd_vma));
 112 static boolean elf32_mn10300_finish_hash_table_entry
 113   PARAMS ((struct bfd_hash_entry *, PTR));
 114 static void compute_function_info
 115   PARAMS ((bfd *, struct elf32_mn10300_link_hash_entry *,
 116            bfd_vma, unsigned char *));
 117
 118 /* We have to use RELA instructions since md_apply_fix3 in the assembler
 119    does absolutely nothing.  */
 120 #define USE_RELA
 121
 122
 123 static reloc_howto_type elf_mn10300_howto_table[] =
 124 {
 125   /* Dummy relocation.  Does nothing.  */
 126   HOWTO (R_MN10300_NONE,
 127          0,
 128          2,
 129          16,
 130          false,
 131          0,
 132          complain_overflow_bitfield,
 133          bfd_elf_generic_reloc,
 134          "R_MN10300_NONE",
 135          false,
 136          0,
 137          0,
 138          false),
 139   /* Standard 32 bit reloc.  */
 140   HOWTO (R_MN10300_32,
 141          0,
 142          2,
 143          32,
 144          false,
 145          0,
 146          complain_overflow_bitfield,
 147          bfd_elf_generic_reloc,
 148          "R_MN10300_32",
 149          false,
 150          0xffffffff,
 151          0xffffffff,
 152          false),
 153   /* Standard 16 bit reloc.  */
 154   HOWTO (R_MN10300_16,
 155          0,
 156          1,
 157          16,
 158          false,
 159          0,
 160          complain_overflow_bitfield,
 161          bfd_elf_generic_reloc,
 162          "R_MN10300_16",
 163          false,
 164          0xffff,
 165          0xffff,
 166          false),
 167   /* Standard 8 bit reloc.  */
 168   HOWTO (R_MN10300_8,
 169          0,
 170          0,
 171          8,
 172          false,
 173          0,
 174          complain_overflow_bitfield,
 175          bfd_elf_generic_reloc,
 176          "R_MN10300_8",
 177          false,
 178          0xff,
 179          0xff,
 180          false),
 181   /* Standard 32bit pc-relative reloc.  */
 182   HOWTO (R_MN10300_PCREL32,
 183          0,
 184          2,
 185          32,
 186          true,
 187          0,
 188          complain_overflow_bitfield,
 189          bfd_elf_generic_reloc,
 190          "R_MN10300_PCREL32",
 191          false,
 192          0xffffffff,
 193          0xffffffff,
 194          true),
 195   /* Standard 16bit pc-relative reloc.  */
 196   HOWTO (R_MN10300_PCREL16,
 197          0,
 198          1,
 199          16,
 200          true,
 201          0,
 202          complain_overflow_bitfield,
 203          bfd_elf_generic_reloc,
 204          "R_MN10300_PCREL16",
 205          false,
 206          0xffff,
 207          0xffff,
 208          true),
 209   /* Standard 8 pc-relative reloc.  */
 210   HOWTO (R_MN10300_PCREL8,
 211          0,
 212          0,
 213          8,
 214          true,
 215          0,
 216          complain_overflow_bitfield,
 217          bfd_elf_generic_reloc,
 218          "R_MN10300_PCREL8",
 219          false,
 220          0xff,
 221          0xff,
 222          true),
 223
 224   /* GNU extension to record C++ vtable hierarchy */
 225   HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
 226          0,                     /* rightshift */
 227          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 228          0,                     /* bitsize */
 229          false,                 /* pc_relative */
 230          0,                     /* bitpos */
 231          complain_overflow_dont, /* complain_on_overflow */
 232          NULL,                  /* special_function */
 233          "R_MN10300_GNU_VTINHERIT", /* name */
 234          false,                 /* partial_inplace */
 235          0,                     /* src_mask */
 236          0,                     /* dst_mask */
 237          false),                /* pcrel_offset */
 238
 239   /* GNU extension to record C++ vtable member usage */
 240   HOWTO (R_MN10300_GNU_VTENTRY, /* type */
 241          0,                     /* rightshift */
 242          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 243          0,                     /* bitsize */
 244          false,                 /* pc_relative */
 245          0,                     /* bitpos */
 246          complain_overflow_dont, /* complain_on_overflow */
 247          NULL,                  /* special_function */
 248          "R_MN10300_GNU_VTENTRY", /* name */
 249          false,                 /* partial_inplace */
 250          0,                     /* src_mask */
 251          0,                     /* dst_mask */
 252          false),                /* pcrel_offset */
 253
 254   /* Standard 24 bit reloc.  */
 255   HOWTO (R_MN10300_24,
 256          0,
 257          2,
 258          24,
 259          false,
 260          0,
 261          complain_overflow_bitfield,
 262          bfd_elf_generic_reloc,
 263          "R_MN10300_24",
 264          false,
 265          0xffffff,
 266          0xffffff,
 267          false),
 268
 269 };
 270
 271 struct mn10300_reloc_map
 272 {
 273   bfd_reloc_code_real_type bfd_reloc_val;
 274   unsigned char elf_reloc_val;
 275 };
 276
 277 static const struct mn10300_reloc_map mn10300_reloc_map[] =
 278 {
 279   { BFD_RELOC_NONE, R_MN10300_NONE, },
 280   { BFD_RELOC_32, R_MN10300_32, },
 281   { BFD_RELOC_16, R_MN10300_16, },
 282   { BFD_RELOC_8, R_MN10300_8, },
 283   { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
 284   { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
 285   { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
 286   { BFD_RELOC_24, R_MN10300_24, },
 287   { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
 288   { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
 289 };
 290
 291 static reloc_howto_type *
 292 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
 293      bfd *abfd;
 294      bfd_reloc_code_real_type code;
 295 {
 296   unsigned int i;
 297
 298   for (i = 0;
 299        i < sizeof (mn10300_reloc_map) / sizeof (struct mn10300_reloc_map);
 300        i++)
 301     {
 302       if (mn10300_reloc_map[i].bfd_reloc_val == code)
 303         return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
 304     }
 305
 306   return NULL;
 307 }
 308
 309 /* Set the howto pointer for an MN10300 ELF reloc.  */
 310
 311 static void
 312 mn10300_info_to_howto (abfd, cache_ptr, dst)
 313      bfd *abfd;
 314      arelent *cache_ptr;
 315      Elf32_Internal_Rela *dst;
 316 {
 317   unsigned int r_type;
 318
 319   r_type = ELF32_R_TYPE (dst->r_info);
 320   BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
 321   cache_ptr->howto = &elf_mn10300_howto_table[r_type];
 322 }
 323
 324 /* Look through the relocs for a section during the first phase.
 325    Since we don't do .gots or .plts, we just need to consider the
 326    virtual table relocs for gc.  */
 327
 328 static boolean
 329 mn10300_elf_check_relocs (abfd, info, sec, relocs)
 330      bfd *abfd;
 331      struct bfd_link_info *info;
 332      asection *sec;
 333      const Elf_Internal_Rela *relocs;
 334 {
 335   Elf_Internal_Shdr *symtab_hdr;
 336   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 337   const Elf_Internal_Rela *rel;
 338   const Elf_Internal_Rela *rel_end;
 339
 340   if (info->relocateable)
 341     return true;
 342
 343   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 344   sym_hashes = elf_sym_hashes (abfd);
 345   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
 346   if (!elf_bad_symtab (abfd))
 347     sym_hashes_end -= symtab_hdr->sh_info;
 348
 349   rel_end = relocs + sec->reloc_count;
 350   for (rel = relocs; rel < rel_end; rel++)
 351     {
 352       struct elf_link_hash_entry *h;
 353       unsigned long r_symndx;
 354
 355       r_symndx = ELF32_R_SYM (rel->r_info);
 356       if (r_symndx < symtab_hdr->sh_info)
 357         h = NULL;
 358       else
 359         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 360
 361       switch (ELF32_R_TYPE (rel->r_info))
 362         {
 363         /* This relocation describes the C++ object vtable hierarchy.
 364            Reconstruct it for later use during GC.  */
 365         case R_MN10300_GNU_VTINHERIT:
 366           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 367             return false;
 368           break;
 369
 370         /* This relocation describes which C++ vtable entries are actually
 371            used.  Record for later use during GC.  */
 372         case R_MN10300_GNU_VTENTRY:
 373           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 374             return false;
 375           break;
 376         }
 377     }
 378
 379   return true;
 380 }
 381
 382 /* Return the section that should be marked against GC for a given
 383    relocation.  */
 384
 385 static asection *
 386 mn10300_elf_gc_mark_hook (abfd, info, rel, h, sym)
 387      bfd *abfd;
 388      struct bfd_link_info *info;
 389      Elf_Internal_Rela *rel;
 390      struct elf_link_hash_entry *h;
 391      Elf_Internal_Sym *sym;
 392 {
 393   if (h != NULL)
 394     {
 395       switch (ELF32_R_TYPE (rel->r_info))
 396         {
 397         case R_MN10300_GNU_VTINHERIT:
 398         case R_MN10300_GNU_VTENTRY:
 399           break;
 400
 401         default:
 402           switch (h->root.type)
 403             {
 404             case bfd_link_hash_defined:
 405             case bfd_link_hash_defweak:
 406               return h->root.u.def.section;
 407
 408             case bfd_link_hash_common:
 409               return h->root.u.c.p->section;
 410             }
 411         }
 412     }
 413   else
 414     {
 415       if (!(elf_bad_symtab (abfd)
 416             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
 417           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
 418                 && sym->st_shndx != SHN_COMMON))
 419         {
 420           return bfd_section_from_elf_index (abfd, sym->st_shndx);
 421         }
 422     }
 423
 424   return NULL;
 425 }
 426
 427 /* Perform a relocation as part of a final link.  */
 428 static bfd_reloc_status_type
 429 mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
 430                                  input_section, contents, offset, value,
 431                                  addend, info, sym_sec, is_local)
 432      reloc_howto_type *howto;
 433      bfd *input_bfd;
 434      bfd *output_bfd;
 435      asection *input_section;
 436      bfd_byte *contents;
 437      bfd_vma offset;
 438      bfd_vma value;
 439      bfd_vma addend;
 440      struct bfd_link_info *info;
 441      asection *sym_sec;
 442      int is_local;
 443 {
 444   unsigned long r_type = howto->type;
 445   bfd_byte *hit_data = contents + offset;
 446
 447   switch (r_type)
 448     {
 449     case R_MN10300_NONE:
 450       return bfd_reloc_ok;
 451
 452     case R_MN10300_32:
 453       value += addend;
 454       bfd_put_32 (input_bfd, value, hit_data);
 455       return bfd_reloc_ok;
 456
 457     case R_MN10300_24:
 458       value += addend;
 459
 460       if ((long)value > 0x7fffff || (long)value < -0x800000)
 461         return bfd_reloc_overflow;
 462
 463       bfd_put_8 (input_bfd, value & 0xff, hit_data);
 464       bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
 465       bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
 466       return bfd_reloc_ok;
 467
 468     case R_MN10300_16:
 469       value += addend;
 470
 471       if ((long)value > 0x7fff || (long)value < -0x8000)
 472         return bfd_reloc_overflow;
 473
 474       bfd_put_16 (input_bfd, value, hit_data);
 475       return bfd_reloc_ok;
 476
 477     case R_MN10300_8:
 478       value += addend;
 479
 480       if ((long)value > 0x7f || (long)value < -0x80)
 481         return bfd_reloc_overflow;
 482
 483       bfd_put_8 (input_bfd, value, hit_data);
 484       return bfd_reloc_ok;
 485
 486     case R_MN10300_PCREL8:
 487       value -= (input_section->output_section->vma
 488                 + input_section->output_offset);
 489       value -= offset;
 490       value += addend;
 491
 492       if ((long)value > 0xff || (long)value < -0x100)
 493         return bfd_reloc_overflow;
 494
 495       bfd_put_8 (input_bfd, value, hit_data);
 496       return bfd_reloc_ok;
 497
 498     case R_MN10300_PCREL16:
 499       value -= (input_section->output_section->vma
 500                 + input_section->output_offset);
 501       value -= offset;
 502       value += addend;
 503
 504       if ((long)value > 0xffff || (long)value < -0x10000)
 505         return bfd_reloc_overflow;
 506
 507       bfd_put_16 (input_bfd, value, hit_data);
 508       return bfd_reloc_ok;
 509
 510     case R_MN10300_PCREL32:
 511       value -= (input_section->output_section->vma
 512                 + input_section->output_offset);
 513       value -= offset;
 514       value += addend;
 515
 516       bfd_put_32 (input_bfd, value, hit_data);
 517       return bfd_reloc_ok;
 518
 519     case R_MN10300_GNU_VTINHERIT:
 520     case R_MN10300_GNU_VTENTRY:
 521       return bfd_reloc_ok;
 522
 523     default:
 524       return bfd_reloc_notsupported;
 525     }
 526 }
 527
 528 \f
 529 /* Relocate an MN10300 ELF section.  */
 530 static boolean
 531 mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 532                               contents, relocs, local_syms, local_sections)
 533      bfd *output_bfd;
 534      struct bfd_link_info *info;
 535      bfd *input_bfd;
 536      asection *input_section;
 537      bfd_byte *contents;
 538      Elf_Internal_Rela *relocs;
 539      Elf_Internal_Sym *local_syms;
 540      asection **local_sections;
 541 {
 542   Elf_Internal_Shdr *symtab_hdr;
 543   struct elf32_mn10300_link_hash_entry **sym_hashes;
 544   Elf_Internal_Rela *rel, *relend;
 545
 546   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 547   sym_hashes = (struct elf32_mn10300_link_hash_entry **)
 548                  (elf_sym_hashes (input_bfd));
 549
 550   rel = relocs;
 551   relend = relocs + input_section->reloc_count;
 552   for (; rel < relend; rel++)
 553     {
 554       int r_type;
 555       reloc_howto_type *howto;
 556       unsigned long r_symndx;
 557       Elf_Internal_Sym *sym;
 558       asection *sec;
 559       struct elf32_mn10300_link_hash_entry *h;
 560       bfd_vma relocation;
 561       bfd_reloc_status_type r;
 562
 563       r_symndx = ELF32_R_SYM (rel->r_info);
 564       r_type = ELF32_R_TYPE (rel->r_info);
 565       howto = elf_mn10300_howto_table + r_type;
 566
 567       /* Just skip the vtable gc relocs.  */
 568       if (r_type == R_MN10300_GNU_VTINHERIT
 569           || r_type == R_MN10300_GNU_VTENTRY)
 570         continue;
 571
 572       if (info->relocateable)
 573         {
 574           /* This is a relocateable link.  We don't have to change
 575              anything, unless the reloc is against a section symbol,
 576              in which case we have to adjust according to where the
 577              section symbol winds up in the output section.  */
 578           if (r_symndx < symtab_hdr->sh_info)
 579             {
 580               sym = local_syms + r_symndx;
 581               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 582                 {
 583                   sec = local_sections[r_symndx];
 584                   rel->r_addend += sec->output_offset + sym->st_value;
 585                 }
 586             }
 587
 588           continue;
 589         }
 590
 591       /* This is a final link.  */
 592       h = NULL;
 593       sym = NULL;
 594       sec = NULL;
 595       if (r_symndx < symtab_hdr->sh_info)
 596         {
 597           sym = local_syms + r_symndx;
 598           sec = local_sections[r_symndx];
 599           relocation = (sec->output_section->vma
 600                         + sec->output_offset
 601                         + sym->st_value);
 602         }
 603       else
 604         {
 605           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 606           while (h->root.type == bfd_link_hash_indirect
 607                  || h->root.type == bfd_link_hash_warning)
 608             h = (struct elf32_mn10300_link_hash_entry *) h->root.root.u.i.link;
 609           if (h->root.root.type == bfd_link_hash_defined
 610               || h->root.root.type == bfd_link_hash_defweak)
 611             {
 612               sec = h->root.root.u.def.section;
 613               relocation = (h->root.root.u.def.value
 614                             + sec->output_section->vma
 615                             + sec->output_offset);
 616             }
 617           else if (h->root.root.type == bfd_link_hash_undefweak)
 618             relocation = 0;
 619           else
 620             {
 621               if (! ((*info->callbacks->undefined_symbol)
 622                      (info, h->root.root.root.string, input_bfd,
 623                       input_section, rel->r_offset)))
 624                 return false;
 625               relocation = 0;
 626             }
 627         }
 628
 629       r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
 630                                            input_section,
 631                                            contents, rel->r_offset,
 632                                            relocation, rel->r_addend,
 633                                            info, sec, h == NULL);
 634
 635       if (r != bfd_reloc_ok)
 636         {
 637           const char *name;
 638           const char *msg = (const char *)0;
 639
 640           if (h != NULL)
 641             name = h->root.root.root.string;
 642           else
 643             {
 644               name = (bfd_elf_string_from_elf_section
 645                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
 646               if (name == NULL || *name == '\0')
 647                 name = bfd_section_name (input_bfd, sec);
 648             }
 649
 650           switch (r)
 651             {
 652             case bfd_reloc_overflow:
 653               if (! ((*info->callbacks->reloc_overflow)
 654                      (info, name, howto->name, (bfd_vma) 0,
 655                       input_bfd, input_section, rel->r_offset)))
 656                 return false;
 657               break;
 658
 659             case bfd_reloc_undefined:
 660               if (! ((*info->callbacks->undefined_symbol)
 661                      (info, name, input_bfd, input_section,
 662                       rel->r_offset)))
 663                 return false;
 664               break;
 665
 666             case bfd_reloc_outofrange:
 667               msg = _("internal error: out of range error");
 668               goto common_error;
 669
 670             case bfd_reloc_notsupported:
 671               msg = _("internal error: unsupported relocation error");
 672               goto common_error;
 673
 674             case bfd_reloc_dangerous:
 675               msg = _("internal error: dangerous error");
 676               goto common_error;
 677
 678             default:
 679               msg = _("internal error: unknown error");
 680               /* fall through */
 681
 682             common_error:
 683               if (!((*info->callbacks->warning)
 684                     (info, msg, name, input_bfd, input_section,
 685                      rel->r_offset)))
 686                 return false;
 687               break;
 688             }
 689         }
 690     }
 691
 692   return true;
 693 }
 694
 695 /* Finish initializing one hash table entry.  */
 696 static boolean
 697 elf32_mn10300_finish_hash_table_entry (gen_entry, in_args)
 698      struct bfd_hash_entry *gen_entry;
 699      PTR in_args;
 700 {
 701   struct elf32_mn10300_link_hash_entry *entry;
 702   unsigned int byte_count = 0;
 703
 704   entry = (struct elf32_mn10300_link_hash_entry *)gen_entry;
 705
 706   /* If we already know we want to convert "call" to "calls" for calls
 707      to this symbol, then return now.  */
 708   if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
 709     return true;
 710
 711   /* If there are no named calls to this symbol, or there's nothing we
 712      can move from the function itself into the "call" instruction, then
 713      note that all "call" instructions should be converted into "calls"
 714      instructions and return.  */
 715   if (entry->direct_calls == 0
 716       || (entry->stack_size == 0 && entry->movm_args == 0))
 717     {
 718       /* Make a note that we should convert "call" instructions to "calls"
 719          instructions for calls to this symbol.  */
 720       entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
 721       return true;
 722     }
 723
 724   /* We may be able to move some instructions from the function itself into
 725      the "call" instruction.  Count how many bytes we might be able to
 726      eliminate in the function itself.  */
 727
 728   /* A movm instruction is two bytes.  */
 729   if (entry->movm_args)
 730     byte_count += 2;
 731
 732   /* Count the insn to allocate stack space too.  */
 733   if (entry->stack_size > 0 && entry->stack_size <= 128)
 734     byte_count += 3;
 735   else if (entry->stack_size > 0 && entry->stack_size < 256)
 736     byte_count += 4;
 737
 738   /* If using "call" will result in larger code, then turn all
 739      the associated "call" instructions into "calls" instrutions.  */
 740   if (byte_count < entry->direct_calls)
 741     entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
 742
 743   /* This routine never fails.  */
 744   return true;
 745 }
 746
 747 /* This function handles relaxing for the mn10300.
 748
 749    There's quite a few relaxing opportunites available on the mn10300:
 750
 751         * calls:32 -> calls:16                                     2 bytes
 752         * call:32  -> call:16                                      2 bytes
 753
 754         * call:32 -> calls:32                                      1 byte
 755         * call:16 -> calls:16                                      1 byte
 756                 * These are done anytime using "calls" would result
 757                 in smaller code, or when necessary to preserve the
 758                 meaning of the program.
 759
 760         * call:32                                                  varies
 761         * call:16
 762                 * In some circumstances we can move instructions
 763                 from a function prologue into a "call" instruction.
 764                 This is only done if the resulting code is no larger
 765                 than the original code.
 766
 767
 768         * jmp:32 -> jmp:16                                         2 bytes
 769         * jmp:16 -> bra:8                                          1 byte
 770
 771                 * If the previous instruction is a conditional branch
 772                 around the jump/bra, we may be able to reverse its condition
 773                 and change its target to the jump's target.  The jump/bra
 774                 can then be deleted.                               2 bytes
 775
 776         * mov abs32 -> mov abs16                                   1 or 2 bytes
 777
 778         * Most instructions which accept imm32 can relax to imm16  1 or 2 bytes
 779         - Most instructions which accept imm16 can relax to imm8   1 or 2 bytes
 780
 781         * Most instructions which accept d32 can relax to d16      1 or 2 bytes
 782         - Most instructions which accept d16 can relax to d8       1 or 2 bytes
 783
 784         We don't handle imm16->imm8 or d16->d8 as they're very rare
 785         and somewhat more difficult to support.  */
 786
 787 static boolean
 788 mn10300_elf_relax_section (abfd, sec, link_info, again)
 789      bfd *abfd;
 790      asection *sec;
 791      struct bfd_link_info *link_info;
 792      boolean *again;
 793 {
 794   Elf_Internal_Shdr *symtab_hdr;
 795   Elf_Internal_Rela *internal_relocs = NULL;
 796   Elf_Internal_Rela *free_relocs = NULL;
 797   Elf_Internal_Rela *irel, *irelend;
 798   bfd_byte *contents = NULL;
 799   bfd_byte *free_contents = NULL;
 800   Elf32_External_Sym *extsyms = NULL;
 801   Elf32_External_Sym *free_extsyms = NULL;
 802   struct elf32_mn10300_link_hash_table *hash_table;
 803
 804   /* Assume nothing changes.  */
 805   *again = false;
 806
 807   /* We need a pointer to the mn10300 specific hash table.  */
 808   hash_table = elf32_mn10300_hash_table (link_info);
 809
 810   /* Initialize fields in each hash table entry the first time through.  */
 811   if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
 812     {
 813       bfd *input_bfd;
 814
 815       /* Iterate over all the input bfds.  */
 816       for (input_bfd = link_info->input_bfds;
 817            input_bfd != NULL;
 818            input_bfd = input_bfd->link_next)
 819         {
 820           asection *section;
 821
 822           /* We're going to need all the symbols for each bfd.  */
 823           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 824
 825           /* Get cached copy if it exists.  */
 826           if (symtab_hdr->contents != NULL)
 827             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
 828           else
 829             {
 830               /* Go get them off disk.  */
 831               extsyms = ((Elf32_External_Sym *)
 832                          bfd_malloc (symtab_hdr->sh_size));
 833               if (extsyms == NULL)
 834                 goto error_return;
 835               free_extsyms = extsyms;
 836               if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
 837                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
 838                       != symtab_hdr->sh_size))
 839                 goto error_return;
 840             }
 841
 842           /* Iterate over each section in this bfd.  */
 843           for (section = input_bfd->sections;
 844                section != NULL;
 845                section = section->next)
 846             {
 847               struct elf32_mn10300_link_hash_entry *hash;
 848               Elf_Internal_Sym *sym;
 849               asection *sym_sec;
 850               const char *sym_name;
 851               char *new_name;
 852               Elf_Internal_Shdr *hdr;
 853
 854               /* Get cached copy of section contents if it exists.  */
 855               if (elf_section_data (section)->this_hdr.contents != NULL)
 856                 contents = elf_section_data (section)->this_hdr.contents;
 857               else if (section->_raw_size != 0)
 858                 {
 859                   /* Go get them off disk.  */
 860                   contents = (bfd_byte *)bfd_malloc (section->_raw_size);
 861                   if (contents == NULL)
 862                     goto error_return;
 863                   free_contents = contents;
 864
 865                   if (!bfd_get_section_contents (input_bfd, section,
 866                                                  contents, (file_ptr) 0,
 867                                                  section->_raw_size))
 868                     goto error_return;
 869                 }
 870               else
 871                 {
 872                   contents = NULL;
 873                   free_contents = NULL;
 874                 }
 875
 876               /* If there aren't any relocs, then there's nothing to do.  */
 877               if ((section->flags & SEC_RELOC) != 0
 878                   && section->reloc_count != 0)
 879                 {
 880
 881                   /* Get a copy of the native relocations.  */
 882                   internal_relocs = (_bfd_elf32_link_read_relocs
 883                                      (input_bfd, section, (PTR) NULL,
 884                                       (Elf_Internal_Rela *) NULL,
 885                                       link_info->keep_memory));
 886                   if (internal_relocs == NULL)
 887                     goto error_return;
 888                   if (! link_info->keep_memory)
 889                     free_relocs = internal_relocs;
 890
 891                   /* Now examine each relocation.  */
 892                   irel = internal_relocs;
 893                   irelend = irel + section->reloc_count;
 894                   for (; irel < irelend; irel++)
 895                     {
 896                       long r_type;
 897                       unsigned long r_index;
 898                       unsigned char code;
 899
 900                       r_type = ELF32_R_TYPE (irel->r_info);
 901                       r_index = ELF32_R_SYM (irel->r_info);
 902
 903                       if (r_type < 0 || r_type >= (int)R_MN10300_MAX)
 904                         goto error_return;
 905
 906                       /* We need the name and hash table entry of the target
 907                          symbol!  */
 908                       hash = NULL;
 909                       sym = NULL;
 910                       sym_sec = NULL;
 911
 912                       if (r_index < symtab_hdr->sh_info)
 913                         {
 914                           /* A local symbol.  */
 915                           Elf_Internal_Sym isym;
 916
 917                           bfd_elf32_swap_symbol_in (input_bfd,
 918                                                     extsyms + r_index, &isym);
 919
 920                           if (isym.st_shndx == SHN_UNDEF)
 921                             sym_sec = bfd_und_section_ptr;
 922                           else if (isym.st_shndx > 0
 923                                    && isym.st_shndx < SHN_LORESERVE)
 924                             sym_sec
 925                               = bfd_section_from_elf_index (input_bfd,
 926                                                             isym.st_shndx);
 927                           else if (isym.st_shndx == SHN_ABS)
 928                             sym_sec = bfd_abs_section_ptr;
 929                           else if (isym.st_shndx == SHN_COMMON)
 930                             sym_sec = bfd_com_section_ptr;
 931
 932                           sym_name = bfd_elf_string_from_elf_section (input_bfd,
 933                                                            symtab_hdr->sh_link,
 934                                                            isym.st_name);
 935
 936                           /* If it isn't a function, then we don't care
 937                              about it.  */
 938                           if (r_index < symtab_hdr->sh_info
 939                               && ELF_ST_TYPE (isym.st_info) != STT_FUNC)
 940                             continue;
 941
 942                           /* Tack on an ID so we can uniquely identify this
 943                              local symbol in the global hash table.  */
 944                           new_name = bfd_malloc (strlen (sym_name) + 10);
 945                           if (new_name == 0)
 946                             goto error_return;
 947
 948                           sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
 949                           sym_name = new_name;
 950
 951                           hash = (struct elf32_mn10300_link_hash_entry *)
 952                                    elf_link_hash_lookup (&hash_table->static_hash_table->root,
 953                                                          sym_name, true,
 954                                                          true, false);
 955                           free (new_name);
 956                         }
 957                       else
 958                         {
 959                           r_index -= symtab_hdr->sh_info;
 960                           hash = (struct elf32_mn10300_link_hash_entry *)
 961                                    elf_sym_hashes (input_bfd)[r_index];
 962                         }
 963
 964                       /* If this is not a "call" instruction, then we
 965                          should convert "call" instructions to "calls"
 966                          instructions.  */
 967                       code = bfd_get_8 (input_bfd,
 968                                         contents + irel->r_offset - 1);
 969                       if (code != 0xdd && code != 0xcd)
 970                         hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
 971
 972                       /* If this is a jump/call, then bump the direct_calls
 973                          counter.  Else force "call" to "calls" conversions.  */
 974                       if (r_type == R_MN10300_PCREL32
 975                           || r_type == R_MN10300_PCREL16)
 976                         hash->direct_calls++;
 977                       else
 978                         hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
 979                     }
 980                 }
 981
 982               /* Now look at the actual contents to get the stack size,
 983                  and a list of what registers were saved in the prologue
 984                  (ie movm_args).  */
 985               if ((section->flags & SEC_CODE) != 0)
 986                 {
 987
 988                   Elf32_External_Sym *esym, *esymend;
 989                   int idx, shndx;
 990
 991                   shndx = _bfd_elf_section_from_bfd_section (input_bfd,
 992                                                              section);
 993
 994
 995                   /* Look at each function defined in this section and
 996                      update info for that function.  */
 997                   esym = extsyms;
 998                   esymend = esym + symtab_hdr->sh_info;
 999                   for (; esym < esymend; esym++)
1000                     {
1001                       Elf_Internal_Sym isym;
1002
1003                       bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1004                       if (isym.st_shndx == shndx
1005                           && ELF_ST_TYPE (isym.st_info) == STT_FUNC)
1006                         {
1007                           if (isym.st_shndx == SHN_UNDEF)
1008                             sym_sec = bfd_und_section_ptr;
1009                           else if (isym.st_shndx > 0
1010                                    && isym.st_shndx < SHN_LORESERVE)
1011                             sym_sec
1012                               = bfd_section_from_elf_index (input_bfd,
1013                                                             isym.st_shndx);
1014                           else if (isym.st_shndx == SHN_ABS)
1015                             sym_sec = bfd_abs_section_ptr;
1016                           else if (isym.st_shndx == SHN_COMMON)
1017                             sym_sec = bfd_com_section_ptr;
1018
1019                           sym_name = bfd_elf_string_from_elf_section (input_bfd,
1020                                                         symtab_hdr->sh_link,
1021                                                         isym.st_name);
1022
1023                           /* Tack on an ID so we can uniquely identify this
1024                              local symbol in the global hash table.  */
1025                           new_name = bfd_malloc (strlen (sym_name) + 10);
1026                           if (new_name == 0)
1027                             goto error_return;
1028
1029                           sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1030                           sym_name = new_name;
1031
1032                           hash = (struct elf32_mn10300_link_hash_entry *)
1033                                     elf_link_hash_lookup (&hash_table->static_hash_table->root,
1034                                                           sym_name, true,
1035                                                           true, false);
1036                           free (new_name);
1037                           compute_function_info (input_bfd, hash,
1038                                                  isym.st_value, contents);
1039                         }
1040                     }
1041
1042                   esym = extsyms + symtab_hdr->sh_info;
1043                   esymend = extsyms + (symtab_hdr->sh_size
1044                                        / sizeof (Elf32_External_Sym));
1045                   for (idx = 0; esym < esymend; esym++, idx++)
1046                     {
1047                       Elf_Internal_Sym isym;
1048
1049                       bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1050                       hash = (struct elf32_mn10300_link_hash_entry *)
1051                                elf_sym_hashes (input_bfd)[idx];
1052                       if (isym.st_shndx == shndx
1053                           && ELF_ST_TYPE (isym.st_info) == STT_FUNC
1054                           && (hash)->root.root.u.def.section == section
1055                           && ((hash)->root.root.type == bfd_link_hash_defined
1056                               || (hash)->root.root.type == bfd_link_hash_defweak))
1057                         compute_function_info (input_bfd, hash,
1058                                                (hash)->root.root.u.def.value,
1059                                                contents);
1060                     }
1061                 }
1062
1063               /* Cache or free any memory we allocated for the relocs.  */
1064               if (free_relocs != NULL)
1065                 {
1066                   free (free_relocs);
1067                   free_relocs = NULL;
1068                 }
1069
1070               /* Cache or free any memory we allocated for the contents.  */
1071               if (free_contents != NULL)
1072                 {
1073                   if (! link_info->keep_memory)
1074                     free (free_contents);
1075                   else
1076                     {
1077                       /* Cache the section contents for elf_link_input_bfd.  */
1078                       elf_section_data (section)->this_hdr.contents = contents;
1079                     }
1080                   free_contents = NULL;
1081                 }
1082             }
1083
1084           /* Cache or free any memory we allocated for the symbols.  */
1085           if (free_extsyms != NULL)
1086             {
1087               if (! link_info->keep_memory)
1088                 free (free_extsyms);
1089               else
1090                 {
1091                   /* Cache the symbols for elf_link_input_bfd.  */
1092                   symtab_hdr->contents = extsyms;
1093                 }
1094               free_extsyms = NULL;
1095             }
1096         }
1097
1098       /* Now iterate on each symbol in the hash table and perform
1099          the final initialization steps on each.  */
1100       elf32_mn10300_link_hash_traverse (hash_table,
1101                                         elf32_mn10300_finish_hash_table_entry,
1102                                         NULL);
1103       elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
1104                                         elf32_mn10300_finish_hash_table_entry,
1105                                         NULL);
1106
1107       /* All entries in the hash table are fully initialized.  */
1108       hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
1109
1110       /* Now that everything has been initialized, go through each
1111          code section and delete any prologue insns which will be
1112          redundant because their operations will be performed by
1113          a "call" instruction.  */
1114       for (input_bfd = link_info->input_bfds;
1115            input_bfd != NULL;
1116            input_bfd = input_bfd->link_next)
1117         {
1118           asection *section;
1119
1120           /* We're going to need all the symbols for each bfd.  */
1121           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1122
1123           /* Get cached copy if it exists.  */
1124           if (symtab_hdr->contents != NULL)
1125             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1126           else
1127             {
1128               /* Go get them off disk.  */
1129               extsyms = ((Elf32_External_Sym *)
1130                          bfd_malloc (symtab_hdr->sh_size));
1131               if (extsyms == NULL)
1132                 goto error_return;
1133               free_extsyms = extsyms;
1134               if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1135                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
1136                       != symtab_hdr->sh_size))
1137                 goto error_return;
1138             }
1139
1140           /* Walk over each section in this bfd.  */
1141           for (section = input_bfd->sections;
1142                section != NULL;
1143                section = section->next)
1144             {
1145               int shndx;
1146               Elf32_External_Sym *esym, *esymend;
1147               int idx;
1148
1149               /* Skip non-code sections and empty sections.  */
1150               if ((section->flags & SEC_CODE) == 0 || section->_raw_size == 0)
1151                 continue;
1152
1153               if (section->reloc_count != 0)
1154                 {
1155                   /* Get a copy of the native relocations.  */
1156                   internal_relocs = (_bfd_elf32_link_read_relocs
1157                                      (input_bfd, section, (PTR) NULL,
1158                                       (Elf_Internal_Rela *) NULL,
1159                                       link_info->keep_memory));
1160                   if (internal_relocs == NULL)
1161                     goto error_return;
1162                   if (! link_info->keep_memory)
1163                     free_relocs = internal_relocs;
1164                 }
1165
1166               /* Get cached copy of section contents if it exists.  */
1167               if (elf_section_data (section)->this_hdr.contents != NULL)
1168                 contents = elf_section_data (section)->this_hdr.contents;
1169               else
1170                 {
1171                   /* Go get them off disk.  */
1172                   contents = (bfd_byte *)bfd_malloc (section->_raw_size);
1173                   if (contents == NULL)
1174                     goto error_return;
1175                   free_contents = contents;
1176
1177                   if (!bfd_get_section_contents (input_bfd, section,
1178                                                  contents, (file_ptr) 0,
1179                                                  section->_raw_size))
1180                     goto error_return;
1181                 }
1182
1183
1184               shndx = _bfd_elf_section_from_bfd_section (input_bfd, section);
1185
1186               /* Now look for any function in this section which needs
1187                  insns deleted from its prologue.  */
1188               esym = extsyms;
1189               esymend = esym + symtab_hdr->sh_info;
1190               for (; esym < esymend; esym++)
1191                 {
1192                   Elf_Internal_Sym isym;
1193                   struct elf32_mn10300_link_hash_entry *sym_hash;
1194                   asection *sym_sec;
1195                   const char *sym_name;
1196                   Elf_Internal_Shdr *hdr;
1197                   char *new_name;
1198
1199                   bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1200
1201                   if (isym.st_shndx != shndx)
1202                     continue;
1203
1204                   if (isym.st_shndx == SHN_UNDEF)
1205                     sym_sec = bfd_und_section_ptr;
1206                   else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1207                     sym_sec
1208                       = bfd_section_from_elf_index (input_bfd, isym.st_shndx);
1209                   else if (isym.st_shndx == SHN_ABS)
1210                     sym_sec = bfd_abs_section_ptr;
1211                   else if (isym.st_shndx == SHN_COMMON)
1212                     sym_sec = bfd_com_section_ptr;
1213
1214                   sym_name = bfd_elf_string_from_elf_section (input_bfd,
1215                                                         symtab_hdr->sh_link,
1216                                                         isym.st_name);
1217
1218                   /* Tack on an ID so we can uniquely identify this
1219                      local symbol in the global hash table.  */
1220                   new_name = bfd_malloc (strlen (sym_name) + 10);
1221                   if (new_name == 0)
1222                     goto error_return;
1223                   sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1224                   sym_name = new_name;
1225
1226                   sym_hash = (struct elf32_mn10300_link_hash_entry *)
1227                             elf_link_hash_lookup (&hash_table->static_hash_table->root,
1228                                                   sym_name, false,
1229                                                   false, false);
1230
1231                   free (new_name);
1232                   if (sym_hash == NULL)
1233                     continue;
1234
1235                   if (! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1236                       && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1237                     {
1238                       int bytes = 0;
1239
1240                       /* Note that we've changed things.  */
1241                       elf_section_data (section)->relocs = internal_relocs;
1242                       free_relocs = NULL;
1243
1244                       elf_section_data (section)->this_hdr.contents = contents;
1245                       free_contents = NULL;
1246
1247                       symtab_hdr->contents = (bfd_byte *)extsyms;
1248                       free_extsyms = NULL;
1249
1250                       /* Count how many bytes we're going to delete.  */
1251                       if (sym_hash->movm_args)
1252                         bytes += 2;
1253
1254                       if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1255                         bytes += 3;
1256                       else if (sym_hash->stack_size
1257                                && sym_hash->stack_size < 256)
1258                         bytes += 4;
1259
1260                       /* Note that we've deleted prologue bytes for this
1261                          function.  */
1262                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1263
1264                       /* Actually delete the bytes.  */
1265                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
1266                                                            section,
1267                                                            isym.st_value,
1268                                                            bytes))
1269                         goto error_return;
1270
1271                       /* Something changed.  Not strictly necessary, but
1272                          may lead to more relaxing opportunities.  */
1273                       *again = true;
1274                     }
1275                 }
1276
1277               /* Look for any global functions in this section which
1278                  need insns deleted from their prologues.  */
1279               esym = extsyms + symtab_hdr->sh_info;
1280               esymend = extsyms + (symtab_hdr->sh_size
1281                                    / sizeof (Elf32_External_Sym));
1282               for (idx = 0; esym < esymend; esym++, idx++)
1283                 {
1284                   Elf_Internal_Sym isym;
1285                   struct elf32_mn10300_link_hash_entry *sym_hash;
1286
1287                   bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1288                   sym_hash = (struct elf32_mn10300_link_hash_entry *)
1289                                (elf_sym_hashes (input_bfd)[idx]);
1290                   if (isym.st_shndx == shndx
1291                       && (sym_hash)->root.root.u.def.section == section
1292                       && ! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1293                       && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1294                     {
1295                       int bytes = 0;
1296
1297                       /* Note that we've changed things.  */
1298                       elf_section_data (section)->relocs = internal_relocs;
1299                       free_relocs = NULL;
1300
1301                       elf_section_data (section)->this_hdr.contents = contents;
1302                       free_contents = NULL;
1303
1304                       symtab_hdr->contents = (bfd_byte *)extsyms;
1305                       free_extsyms = NULL;
1306
1307                       /* Count how many bytes we're going to delete.  */
1308                       if (sym_hash->movm_args)
1309                         bytes += 2;
1310
1311                       if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1312                         bytes += 3;
1313                       else if (sym_hash->stack_size
1314                                && sym_hash->stack_size < 256)
1315                         bytes += 4;
1316
1317                       /* Note that we've deleted prologue bytes for this
1318                          function.  */
1319                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1320
1321                       /* Actually delete the bytes.  */
1322                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
1323                                                            section,
1324                                                            (sym_hash)->root.root.u.def.value,
1325                                                            bytes))
1326                         goto error_return;
1327
1328                       /* Something changed.  Not strictly necessary, but
1329                          may lead to more relaxing opportunities.  */
1330                       *again = true;
1331                     }
1332                 }
1333
1334               /* Cache or free any memory we allocated for the relocs.  */
1335               if (free_relocs != NULL)
1336                 {
1337                   free (free_relocs);
1338                   free_relocs = NULL;
1339                 }
1340
1341               /* Cache or free any memory we allocated for the contents.  */
1342               if (free_contents != NULL)
1343                 {
1344                   if (! link_info->keep_memory)
1345                     free (free_contents);
1346                   else
1347                     {
1348                       /* Cache the section contents for elf_link_input_bfd.  */
1349                       elf_section_data (section)->this_hdr.contents = contents;
1350                     }
1351                   free_contents = NULL;
1352                 }
1353             }
1354
1355           /* Cache or free any memory we allocated for the symbols.  */
1356           if (free_extsyms != NULL)
1357             {
1358               if (! link_info->keep_memory)
1359                 free (free_extsyms);
1360               else
1361                 {
1362                   /* Cache the symbols for elf_link_input_bfd.  */
1363                   symtab_hdr->contents = extsyms;
1364                 }
1365               free_extsyms = NULL;
1366             }
1367         }
1368     }
1369
1370
1371   /* (Re)initialize for the basic instruction shortening/relaxing pass.  */
1372   contents = NULL;
1373   extsyms = NULL;
1374   internal_relocs = NULL;
1375   free_relocs = NULL;
1376   free_contents = NULL;
1377   free_extsyms = NULL;
1378
1379   /* We don't have to do anything for a relocateable link, if
1380      this section does not have relocs, or if this is not a
1381      code section.  */
1382   if (link_info->relocateable
1383       || (sec->flags & SEC_RELOC) == 0
1384       || sec->reloc_count == 0
1385       || (sec->flags & SEC_CODE) == 0)
1386     return true;
1387
1388   /* If this is the first time we have been called for this section,
1389      initialize the cooked size.  */
1390   if (sec->_cooked_size == 0)
1391     sec->_cooked_size = sec->_raw_size;
1392
1393   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1394
1395   /* Get a copy of the native relocations.  */
1396   internal_relocs = (_bfd_elf32_link_read_relocs
1397                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1398                       link_info->keep_memory));
1399   if (internal_relocs == NULL)
1400     goto error_return;
1401   if (! link_info->keep_memory)
1402     free_relocs = internal_relocs;
1403
1404   /* Walk through them looking for relaxing opportunities.  */
1405   irelend = internal_relocs + sec->reloc_count;
1406   for (irel = internal_relocs; irel < irelend; irel++)
1407     {
1408       bfd_vma symval;
1409       struct elf32_mn10300_link_hash_entry *h = NULL;
1410
1411       /* If this isn't something that can be relaxed, then ignore
1412          this reloc.  */
1413       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
1414           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
1415           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
1416         continue;
1417
1418       /* Get the section contents if we haven't done so already.  */
1419       if (contents == NULL)
1420         {
1421           /* Get cached copy if it exists.  */
1422           if (elf_section_data (sec)->this_hdr.contents != NULL)
1423             contents = elf_section_data (sec)->this_hdr.contents;
1424           else
1425             {
1426               /* Go get them off disk.  */
1427               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1428               if (contents == NULL)
1429                 goto error_return;
1430               free_contents = contents;
1431
1432               if (! bfd_get_section_contents (abfd, sec, contents,
1433                                               (file_ptr) 0, sec->_raw_size))
1434                 goto error_return;
1435             }
1436         }
1437
1438       /* Read this BFD's symbols if we haven't done so already.  */
1439       if (extsyms == NULL)
1440         {
1441           /* Get cached copy if it exists.  */
1442           if (symtab_hdr->contents != NULL)
1443             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1444           else
1445             {
1446               /* Go get them off disk.  */
1447               extsyms = ((Elf32_External_Sym *)
1448                          bfd_malloc (symtab_hdr->sh_size));
1449               if (extsyms == NULL)
1450                 goto error_return;
1451               free_extsyms = extsyms;
1452               if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1453                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1454                       != symtab_hdr->sh_size))
1455                 goto error_return;
1456             }
1457         }
1458
1459       /* Get the value of the symbol referred to by the reloc.  */
1460       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1461         {
1462           Elf_Internal_Sym isym;
1463           asection *sym_sec;
1464           Elf_Internal_Shdr *hdr;
1465           const char *sym_name;
1466           char *new_name;
1467
1468           /* A local symbol.  */
1469           bfd_elf32_swap_symbol_in (abfd,
1470                                     extsyms + ELF32_R_SYM (irel->r_info),
1471                                     &isym);
1472
1473           if (isym.st_shndx == SHN_UNDEF)
1474             sym_sec = bfd_und_section_ptr;
1475           else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1476             sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1477           else if (isym.st_shndx == SHN_ABS)
1478             sym_sec = bfd_abs_section_ptr;
1479           else if (isym.st_shndx == SHN_COMMON)
1480             sym_sec = bfd_com_section_ptr;
1481
1482           symval = (isym.st_value
1483                     + sym_sec->output_section->vma
1484                     + sym_sec->output_offset);
1485           sym_name = bfd_elf_string_from_elf_section (abfd,
1486                                                       symtab_hdr->sh_link,
1487                                                       isym.st_name);
1488
1489           /* Tack on an ID so we can uniquely identify this
1490              local symbol in the global hash table.  */
1491           new_name = bfd_malloc (strlen (sym_name) + 10);
1492           if (new_name == 0)
1493             goto error_return;
1494           sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1495           sym_name = new_name;
1496
1497           h = (struct elf32_mn10300_link_hash_entry *)
1498                 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1499                                       sym_name, false, false, false);
1500           free (new_name);
1501         }
1502       else
1503         {
1504           unsigned long indx;
1505
1506           /* An external symbol.  */
1507           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1508           h = (struct elf32_mn10300_link_hash_entry *)
1509                 (elf_sym_hashes (abfd)[indx]);
1510           BFD_ASSERT (h != NULL);
1511           if (h->root.root.type != bfd_link_hash_defined
1512               && h->root.root.type != bfd_link_hash_defweak)
1513             {
1514               /* This appears to be a reference to an undefined
1515                 symbol.  Just ignore it--it will be caught by the
1516                 regular reloc processing.  */
1517               continue;
1518             }
1519
1520           symval = (h->root.root.u.def.value
1521                     + h->root.root.u.def.section->output_section->vma
1522                     + h->root.root.u.def.section->output_offset);
1523         }
1524
1525       /* For simplicity of coding, we are going to modify the section
1526          contents, the section relocs, and the BFD symbol table.  We
1527          must tell the rest of the code not to free up this
1528          information.  It would be possible to instead create a table
1529          of changes which have to be made, as is done in coff-mips.c;
1530          that would be more work, but would require less memory when
1531          the linker is run.  */
1532
1533       /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
1534          branch/call, also deal with "call" -> "calls" conversions and
1535          insertion of prologue data into "call" instructions.  */
1536       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32)
1537         {
1538           bfd_vma value = symval;
1539
1540           /* If we've got a "call" instruction that needs to be turned
1541              into a "calls" instruction, do so now.  It saves a byte.  */
1542           if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1543             {
1544               unsigned char code;
1545
1546               /* Get the opcode.  */
1547               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1548
1549               /* Make sure we're working with a "call" instruction!  */
1550               if (code == 0xdd)
1551                 {
1552                   /* Note that we've changed the relocs, section contents,
1553                      etc.  */
1554                   elf_section_data (sec)->relocs = internal_relocs;
1555                   free_relocs = NULL;
1556
1557                   elf_section_data (sec)->this_hdr.contents = contents;
1558                   free_contents = NULL;
1559
1560                   symtab_hdr->contents = (bfd_byte *) extsyms;
1561                   free_extsyms = NULL;
1562
1563                   /* Fix the opcode.  */
1564                   bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
1565                   bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1566
1567                   /* Fix irel->r_offset and irel->r_addend.  */
1568                   irel->r_offset += 1;
1569                   irel->r_addend += 1;
1570
1571                   /* Delete one byte of data.  */
1572                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1573                                                        irel->r_offset + 3, 1))
1574                     goto error_return;
1575
1576                   /* That will change things, so, we should relax again.
1577                      Note that this is not required, and it may be slow.  */
1578                   *again = true;
1579                 }
1580             }
1581           else if (h)
1582             {
1583               /* We've got a "call" instruction which needs some data
1584                  from target function filled in.  */
1585               unsigned char code;
1586
1587               /* Get the opcode.  */
1588               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1589
1590               /* Insert data from the target function into the "call"
1591                  instruction if needed.  */
1592               if (code == 0xdd)
1593                 {
1594                   bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
1595                   bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1596                              contents + irel->r_offset + 5);
1597                 }
1598             }
1599
1600           /* Deal with pc-relative gunk.  */
1601           value -= (sec->output_section->vma + sec->output_offset);
1602           value -= irel->r_offset;
1603           value += irel->r_addend;
1604
1605           /* See if the value will fit in 16 bits, note the high value is
1606              0x7fff + 2 as the target will be two bytes closer if we are
1607              able to relax.  */
1608           if ((long)value < 0x8001 && (long)value > -0x8000)
1609             {
1610               unsigned char code;
1611
1612               /* Get the opcode.  */
1613               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1614
1615               if (code != 0xdc && code != 0xdd && code != 0xff)
1616                 continue;
1617
1618               /* Note that we've changed the relocs, section contents, etc.  */
1619               elf_section_data (sec)->relocs = internal_relocs;
1620               free_relocs = NULL;
1621
1622               elf_section_data (sec)->this_hdr.contents = contents;
1623               free_contents = NULL;
1624
1625               symtab_hdr->contents = (bfd_byte *) extsyms;
1626               free_extsyms = NULL;
1627
1628               /* Fix the opcode.  */
1629               if (code == 0xdc)
1630                 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
1631               else if (code == 0xdd)
1632                 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
1633               else if (code == 0xff)
1634                 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1635
1636               /* Fix the relocation's type.  */
1637               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1638                                            R_MN10300_PCREL16);
1639
1640               /* Delete two bytes of data.  */
1641               if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1642                                                    irel->r_offset + 1, 2))
1643                 goto error_return;
1644
1645               /* That will change things, so, we should relax again.
1646                  Note that this is not required, and it may be slow.  */
1647               *again = true;
1648             }
1649         }
1650
1651       /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
1652          branch.  */
1653       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
1654         {
1655           bfd_vma value = symval;
1656
1657           /* If we've got a "call" instruction that needs to be turned
1658              into a "calls" instruction, do so now.  It saves a byte.  */
1659           if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1660             {
1661               unsigned char code;
1662
1663               /* Get the opcode.  */
1664               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1665
1666               /* Make sure we're working with a "call" instruction!  */
1667               if (code == 0xcd)
1668                 {
1669                   /* Note that we've changed the relocs, section contents,
1670                      etc.  */
1671                   elf_section_data (sec)->relocs = internal_relocs;
1672                   free_relocs = NULL;
1673
1674                   elf_section_data (sec)->this_hdr.contents = contents;
1675                   free_contents = NULL;
1676
1677                   symtab_hdr->contents = (bfd_byte *) extsyms;
1678                   free_extsyms = NULL;
1679
1680                   /* Fix the opcode.  */
1681                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
1682                   bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1683
1684                   /* Fix irel->r_offset and irel->r_addend.  */
1685                   irel->r_offset += 1;
1686                   irel->r_addend += 1;
1687
1688                   /* Delete one byte of data.  */
1689                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1690                                                        irel->r_offset + 1, 1))
1691                     goto error_return;
1692
1693                   /* That will change things, so, we should relax again.
1694                      Note that this is not required, and it may be slow.  */
1695                   *again = true;
1696                 }
1697             }
1698           else if (h)
1699             {
1700               unsigned char code;
1701
1702               /* Get the opcode.  */
1703               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1704
1705               /* Insert data from the target function into the "call"
1706                  instruction if needed.  */
1707               if (code == 0xcd)
1708                 {
1709                   bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
1710                   bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1711                              contents + irel->r_offset + 3);
1712                 }
1713             }
1714
1715           /* Deal with pc-relative gunk.  */
1716           value -= (sec->output_section->vma + sec->output_offset);
1717           value -= irel->r_offset;
1718           value += irel->r_addend;
1719
1720           /* See if the value will fit in 8 bits, note the high value is
1721              0x7f + 1 as the target will be one bytes closer if we are
1722              able to relax.  */
1723           if ((long)value < 0x80 && (long)value > -0x80)
1724             {
1725               unsigned char code;
1726
1727               /* Get the opcode.  */
1728               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1729
1730               if (code != 0xcc)
1731                 continue;
1732
1733               /* Note that we've changed the relocs, section contents, etc.  */
1734               elf_section_data (sec)->relocs = internal_relocs;
1735               free_relocs = NULL;
1736
1737               elf_section_data (sec)->this_hdr.contents = contents;
1738               free_contents = NULL;
1739
1740               symtab_hdr->contents = (bfd_byte *) extsyms;
1741               free_extsyms = NULL;
1742
1743               /* Fix the opcode.  */
1744               bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
1745
1746               /* Fix the relocation's type.  */
1747               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1748                                            R_MN10300_PCREL8);
1749
1750               /* Delete one byte of data.  */
1751               if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1752                                                    irel->r_offset + 1, 1))
1753                 goto error_return;
1754
1755               /* That will change things, so, we should relax again.
1756                  Note that this is not required, and it may be slow.  */
1757               *again = true;
1758             }
1759         }
1760
1761       /* Try to eliminate an unconditional 8 bit pc-relative branch
1762          which immediately follows a conditional 8 bit pc-relative
1763          branch around the unconditional branch.
1764
1765             original:           new:
1766             bCC lab1            bCC' lab2
1767             bra lab2
1768            lab1:               lab1:
1769
1770
1771          This happens when the bCC can't reach lab2 at assembly time,
1772          but due to other relaxations it can reach at link time.  */
1773       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
1774         {
1775           Elf_Internal_Rela *nrel;
1776           bfd_vma value = symval;
1777           unsigned char code;
1778
1779           /* Deal with pc-relative gunk.  */
1780           value -= (sec->output_section->vma + sec->output_offset);
1781           value -= irel->r_offset;
1782           value += irel->r_addend;
1783
1784           /* Do nothing if this reloc is the last byte in the section.  */
1785           if (irel->r_offset == sec->_cooked_size)
1786             continue;
1787
1788           /* See if the next instruction is an unconditional pc-relative
1789              branch, more often than not this test will fail, so we
1790              test it first to speed things up.  */
1791           code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1792           if (code != 0xca)
1793             continue;
1794
1795           /* Also make sure the next relocation applies to the next
1796              instruction and that it's a pc-relative 8 bit branch.  */
1797           nrel = irel + 1;
1798           if (nrel == irelend
1799               || irel->r_offset + 2 != nrel->r_offset
1800               || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
1801             continue;
1802
1803           /* Make sure our destination immediately follows the
1804              unconditional branch.  */
1805           if (symval != (sec->output_section->vma + sec->output_offset
1806                          + irel->r_offset + 3))
1807             continue;
1808
1809           /* Now make sure we are a conditional branch.  This may not
1810              be necessary, but why take the chance.
1811
1812              Note these checks assume that R_MN10300_PCREL8 relocs
1813              only occur on bCC and bCCx insns.  If they occured
1814              elsewhere, we'd need to know the start of this insn
1815              for this check to be accurate.  */
1816           code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1817           if (code != 0xc0 && code != 0xc1 && code != 0xc2
1818               && code != 0xc3 && code != 0xc4 && code != 0xc5
1819               && code != 0xc6 && code != 0xc7 && code != 0xc8
1820               && code != 0xc9 && code != 0xe8 && code != 0xe9
1821               && code != 0xea && code != 0xeb)
1822             continue;
1823
1824           /* We also have to be sure there is no symbol/label
1825              at the unconditional branch.  */
1826           if (mn10300_elf_symbol_address_p (abfd, sec, extsyms,
1827                                             irel->r_offset + 1))
1828             continue;
1829
1830           /* Note that we've changed the relocs, section contents, etc.  */
1831           elf_section_data (sec)->relocs = internal_relocs;
1832           free_relocs = NULL;
1833
1834           elf_section_data (sec)->this_hdr.contents = contents;
1835           free_contents = NULL;
1836
1837           symtab_hdr->contents = (bfd_byte *) extsyms;
1838           free_extsyms = NULL;
1839
1840           /* Reverse the condition of the first branch.  */
1841           switch (code)
1842             {
1843               case 0xc8:
1844                 code = 0xc9;
1845                 break;
1846               case 0xc9:
1847                 code = 0xc8;
1848                 break;
1849               case 0xc0:
1850                 code = 0xc2;
1851                 break;
1852               case 0xc2:
1853                 code = 0xc0;
1854                 break;
1855               case 0xc3:
1856                 code = 0xc1;
1857                 break;
1858               case 0xc1:
1859                 code = 0xc3;
1860                 break;
1861               case 0xc4:
1862                 code = 0xc6;
1863                 break;
1864               case 0xc6:
1865                 code = 0xc4;
1866                 break;
1867               case 0xc7:
1868                 code = 0xc5;
1869                 break;
1870               case 0xc5:
1871                 code = 0xc7;
1872                 break;
1873               case 0xe8:
1874                 code = 0xe9;
1875                 break;
1876               case 0x9d:
1877                 code = 0xe8;
1878                 break;
1879               case 0xea:
1880                 code = 0xeb;
1881                 break;
1882               case 0xeb:
1883                 code = 0xea;
1884                 break;
1885             }
1886           bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1887
1888           /* Set the reloc type and symbol for the first branch
1889              from the second branch.  */
1890           irel->r_info = nrel->r_info;
1891
1892           /* Make the reloc for the second branch a null reloc.  */
1893           nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1894                                        R_MN10300_NONE);
1895
1896           /* Delete two bytes of data.  */
1897           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1898                                                irel->r_offset + 1, 2))
1899             goto error_return;
1900
1901           /* That will change things, so, we should relax again.
1902              Note that this is not required, and it may be slow.  */
1903           *again = true;
1904         }
1905
1906
1907       /* Try to turn a 32bit immediate, displacement or absolute address
1908          into a 16bit immediate, displacement or absolute address.  */
1909       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32)
1910         {
1911           bfd_vma value = symval;
1912           value += irel->r_addend;
1913
1914
1915           /* See if the value will fit in 16 bits.
1916              We allow any 16bit match here.  We prune those we can't
1917              handle below.  */
1918           if ((long)value < 0x7fff && (long)value > -0x8000)
1919             {
1920               unsigned char code;
1921
1922               /* Most insns which have 32bit operands are 6 bytes long;
1923                  exceptions are pcrel insns and bit insns.
1924
1925                  We handle pcrel insns above.  We don't bother trying
1926                  to handle the bit insns here.
1927
1928                  The first byte of the remaining insns will be 0xfc.  */
1929
1930               /* Get the first opcode.  */
1931               code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1932
1933               if (code != 0xfc)
1934                 continue;
1935
1936               /* Get the second opcode.  */
1937               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1938
1939               if ((code & 0xf0) < 0x80)
1940                 switch (code & 0xf0)
1941                   {
1942                   /* mov (d32,am),dn   -> mov (d32,am),dn
1943                      mov dm,(d32,am)   -> mov dn,(d32,am)
1944                      mov (d32,am),an   -> mov (d32,am),an
1945                      mov dm,(d32,am)   -> mov dn,(d32,am)
1946                      movbu (d32,am),dn -> movbu (d32,am),dn
1947                      movbu dm,(d32,am) -> movbu dn,(d32,am)
1948                      movhu (d32,am),dn -> movhu (d32,am),dn
1949                      movhu dm,(d32,am) -> movhu dn,(d32,am) */
1950                   case 0x00:
1951                   case 0x10:
1952                   case 0x20:
1953                   case 0x30:
1954                   case 0x40:
1955                   case 0x50:
1956                   case 0x60:
1957                   case 0x70:
1958                     /* Not safe if the high bit is on as relaxing may
1959                        move the value out of high mem and thus not fit
1960                        in a signed 16bit value.  */
1961                     if (code == 0xcc
1962                         && (value & 0x8000))
1963                       continue;
1964
1965                     /* Note that we've changed the relocation contents, etc.  */
1966                     elf_section_data (sec)->relocs = internal_relocs;
1967                     free_relocs = NULL;
1968
1969                     elf_section_data (sec)->this_hdr.contents = contents;
1970                     free_contents = NULL;
1971
1972                     symtab_hdr->contents = (bfd_byte *) extsyms;
1973                     free_extsyms = NULL;
1974
1975                     /* Fix the opcode.  */
1976                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1977                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1978
1979                     /* Fix the relocation's type.  */
1980                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1981                                                  R_MN10300_16);
1982
1983                     /* Delete two bytes of data.  */
1984                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1985                                                          irel->r_offset + 2, 2))
1986                       goto error_return;
1987
1988                     /* That will change things, so, we should relax again.
1989                        Note that this is not required, and it may be slow.  */
1990                     *again = true;
1991                     break;
1992                   }
1993               else if ((code & 0xf0) == 0x80
1994                        || (code & 0xf0) == 0x90)
1995                 switch (code & 0xf3)
1996                   {
1997                   /* mov dn,(abs32)   -> mov dn,(abs16)
1998                      movbu dn,(abs32) -> movbu dn,(abs16)
1999                      movhu dn,(abs32) -> movhu dn,(abs16)  */
2000                   case 0x81:
2001                   case 0x82:
2002                   case 0x83:
2003                     /* Note that we've changed the relocation contents, etc.  */
2004                     elf_section_data (sec)->relocs = internal_relocs;
2005                     free_relocs = NULL;
2006
2007                     elf_section_data (sec)->this_hdr.contents = contents;
2008                     free_contents = NULL;
2009
2010                     symtab_hdr->contents = (bfd_byte *) extsyms;
2011                     free_extsyms = NULL;
2012
2013                     if ((code & 0xf3) == 0x81)
2014                       code = 0x01 + (code & 0x0c);
2015                     else if ((code & 0xf3) == 0x82)
2016                       code = 0x02 + (code & 0x0c);
2017                     else if ((code & 0xf3) == 0x83)
2018                       code = 0x03 + (code & 0x0c);
2019                     else
2020                       abort ();
2021
2022                     /* Fix the opcode.  */
2023                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2024
2025                     /* Fix the relocation's type.  */
2026                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2027                                                  R_MN10300_16);
2028
2029                     /* The opcode got shorter too, so we have to fix the
2030                        addend and offset too!  */
2031                     irel->r_offset -= 1;
2032
2033                     /* Delete three bytes of data.  */
2034                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2035                                                          irel->r_offset + 1, 3))
2036                       goto error_return;
2037
2038                     /* That will change things, so, we should relax again.
2039                        Note that this is not required, and it may be slow.  */
2040                     *again = true;
2041                     break;
2042
2043                   /* mov am,(abs32)    -> mov am,(abs16)
2044                      mov am,(d32,sp)   -> mov am,(d16,sp)
2045                      mov dm,(d32,sp)   -> mov dm,(d32,sp)
2046                      movbu dm,(d32,sp) -> movbu dm,(d32,sp)
2047                      movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
2048                   case 0x80:
2049                   case 0x90:
2050                   case 0x91:
2051                   case 0x92:
2052                   case 0x93:
2053                     /* Note that we've changed the relocation contents, etc.  */
2054                     elf_section_data (sec)->relocs = internal_relocs;
2055                     free_relocs = NULL;
2056
2057                     elf_section_data (sec)->this_hdr.contents = contents;
2058                     free_contents = NULL;
2059
2060                     symtab_hdr->contents = (bfd_byte *) extsyms;
2061                     free_extsyms = NULL;
2062
2063                     /* Fix the opcode.  */
2064                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2065                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2066
2067                     /* Fix the relocation's type.  */
2068                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2069                                                  R_MN10300_16);
2070
2071                     /* Delete two bytes of data.  */
2072                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2073                                                          irel->r_offset + 2, 2))
2074                       goto error_return;
2075
2076                     /* That will change things, so, we should relax again.
2077                        Note that this is not required, and it may be slow.  */
2078                     *again = true;
2079                     break;
2080                   }
2081               else if ((code & 0xf0) < 0xf0)
2082                 switch (code & 0xfc)
2083                   {
2084                   /* mov imm32,dn     -> mov imm16,dn
2085                      mov imm32,an     -> mov imm16,an
2086                      mov (abs32),dn   -> mov (abs16),dn
2087                      movbu (abs32),dn -> movbu (abs16),dn
2088                      movhu (abs32),dn -> movhu (abs16),dn  */
2089                   case 0xcc:
2090                   case 0xdc:
2091                   case 0xa4:
2092                   case 0xa8:
2093                   case 0xac:
2094                     /* Not safe if the high bit is on as relaxing may
2095                        move the value out of high mem and thus not fit
2096                        in a signed 16bit value.  */
2097                     if (code == 0xcc
2098                         && (value & 0x8000))
2099                       continue;
2100
2101                     /* Note that we've changed the relocation contents, etc.  */
2102                     elf_section_data (sec)->relocs = internal_relocs;
2103                     free_relocs = NULL;
2104
2105                     elf_section_data (sec)->this_hdr.contents = contents;
2106                     free_contents = NULL;
2107
2108                     symtab_hdr->contents = (bfd_byte *) extsyms;
2109                     free_extsyms = NULL;
2110
2111                     if ((code & 0xfc) == 0xcc)
2112                       code = 0x2c + (code & 0x03);
2113                     else if ((code & 0xfc) == 0xdc)
2114                       code = 0x24 + (code & 0x03);
2115                     else if ((code & 0xfc) == 0xa4)
2116                       code = 0x30 + (code & 0x03);
2117                     else if ((code & 0xfc) == 0xa8)
2118                       code = 0x34 + (code & 0x03);
2119                     else if ((code & 0xfc) == 0xac)
2120                       code = 0x38 + (code & 0x03);
2121                     else
2122                       abort ();
2123
2124                     /* Fix the opcode.  */
2125                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2126
2127                     /* Fix the relocation's type.  */
2128                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2129                                                  R_MN10300_16);
2130
2131                     /* The opcode got shorter too, so we have to fix the
2132                        addend and offset too!  */
2133                     irel->r_offset -= 1;
2134
2135                     /* Delete three bytes of data.  */
2136                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2137                                                          irel->r_offset + 1, 3))
2138                       goto error_return;
2139
2140                     /* That will change things, so, we should relax again.
2141                        Note that this is not required, and it may be slow.  */
2142                     *again = true;
2143                     break;
2144
2145                   /* mov (abs32),an    -> mov (abs16),an
2146                      mov (d32,sp),an   -> mov (d32,sp),an
2147                      mov (d32,sp),dn   -> mov (d32,sp),dn
2148                      movbu (d32,sp),dn -> movbu (d32,sp),dn
2149                      movhu (d32,sp),dn -> movhu (d32,sp),dn
2150                      add imm32,dn      -> add imm16,dn
2151                      cmp imm32,dn      -> cmp imm16,dn
2152                      add imm32,an      -> add imm16,an
2153                      cmp imm32,an      -> cmp imm16,an
2154                      and imm32,dn      -> and imm32,dn
2155                      or imm32,dn       -> or imm32,dn
2156                      xor imm32,dn      -> xor imm32,dn
2157                      btst imm32,dn     -> btst imm32,dn */
2158
2159                   case 0xa0:
2160                   case 0xb0:
2161                   case 0xb1:
2162                   case 0xb2:
2163                   case 0xb3:
2164                   case 0xc0:
2165                   case 0xc8:
2166
2167                   case 0xd0:
2168                   case 0xd8:
2169                   case 0xe0:
2170                   case 0xe1:
2171                   case 0xe2:
2172                   case 0xe3:
2173                     /* Note that we've changed the relocation contents, etc.  */
2174                     elf_section_data (sec)->relocs = internal_relocs;
2175                     free_relocs = NULL;
2176
2177                     elf_section_data (sec)->this_hdr.contents = contents;
2178                     free_contents = NULL;
2179
2180                     symtab_hdr->contents = (bfd_byte *) extsyms;
2181                     free_extsyms = NULL;
2182
2183                     /* Fix the opcode.  */
2184                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2185                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2186
2187                     /* Fix the relocation's type.  */
2188                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2189                                                  R_MN10300_16);
2190
2191                     /* Delete two bytes of data.  */
2192                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2193                                                          irel->r_offset + 2, 2))
2194                       goto error_return;
2195
2196                     /* That will change things, so, we should relax again.
2197                        Note that this is not required, and it may be slow.  */
2198                     *again = true;
2199                     break;
2200                   }
2201               else if (code == 0xfe)
2202                 {
2203                   /* add imm32,sp -> add imm16,sp  */
2204
2205                   /* Note that we've changed the relocation contents, etc.  */
2206                   elf_section_data (sec)->relocs = internal_relocs;
2207                   free_relocs = NULL;
2208
2209                   elf_section_data (sec)->this_hdr.contents = contents;
2210                   free_contents = NULL;
2211
2212                   symtab_hdr->contents = (bfd_byte *) extsyms;
2213                   free_extsyms = NULL;
2214
2215                   /* Fix the opcode.  */
2216                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2217                   bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
2218
2219                   /* Fix the relocation's type.  */
2220                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2221                                                  R_MN10300_16);
2222
2223                   /* Delete two bytes of data.  */
2224                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2225                                                        irel->r_offset + 2, 2))
2226                     goto error_return;
2227
2228                   /* That will change things, so, we should relax again.
2229                      Note that this is not required, and it may be slow.  */
2230                   *again = true;
2231                   break;
2232                 }
2233             }
2234         }
2235     }
2236
2237   if (free_relocs != NULL)
2238     {
2239       free (free_relocs);
2240       free_relocs = NULL;
2241     }
2242
2243   if (free_contents != NULL)
2244     {
2245       if (! link_info->keep_memory)
2246         free (free_contents);
2247       else
2248         {
2249           /* Cache the section contents for elf_link_input_bfd.  */
2250           elf_section_data (sec)->this_hdr.contents = contents;
2251         }
2252       free_contents = NULL;
2253     }
2254
2255   if (free_extsyms != NULL)
2256     {
2257       if (! link_info->keep_memory)
2258         free (free_extsyms);
2259       else
2260         {
2261           /* Cache the symbols for elf_link_input_bfd.  */
2262           symtab_hdr->contents = extsyms;
2263         }
2264       free_extsyms = NULL;
2265     }
2266
2267   return true;
2268
2269  error_return:
2270   if (free_relocs != NULL)
2271     free (free_relocs);
2272   if (free_contents != NULL)
2273     free (free_contents);
2274   if (free_extsyms != NULL)
2275     free (free_extsyms);
2276   return false;
2277 }
2278
2279 /* Compute the stack size and movm arguments for the function
2280    referred to by HASH at address ADDR in section with
2281    contents CONTENTS, store the information in the hash table.  */
2282 static void
2283 compute_function_info (abfd, hash, addr, contents)
2284      bfd *abfd;
2285      struct elf32_mn10300_link_hash_entry *hash;
2286      bfd_vma addr;
2287      unsigned char *contents;
2288 {
2289   unsigned char byte1, byte2;
2290   /* We only care about a very small subset of the possible prologue
2291      sequences here.  Basically we look for:
2292
2293      movm [d2,d3,a2,a3],sp (optional)
2294      add <size>,sp (optional, and only for sizes which fit in an unsigned
2295                     8 bit number)
2296
2297      If we find anything else, we quit.  */
2298
2299   /* Look for movm [regs],sp */
2300   byte1 = bfd_get_8 (abfd, contents + addr);
2301   byte2 = bfd_get_8 (abfd, contents + addr + 1);
2302
2303   if (byte1 == 0xcf)
2304     {
2305       hash->movm_args = byte2;
2306       addr += 2;
2307       byte1 = bfd_get_8 (abfd, contents + addr);
2308       byte2 = bfd_get_8 (abfd, contents + addr + 1);
2309     }
2310
2311   /* Now figure out how much stack space will be allocated by the movm
2312      instruction.  We need this kept separate from the funtion's normal
2313      stack space.  */
2314   if (hash->movm_args)
2315     {
2316       /* Space for d2.  */
2317       if (hash->movm_args & 0x80)
2318         hash->movm_stack_size += 4;
2319
2320       /* Space for d3.  */
2321       if (hash->movm_args & 0x40)
2322         hash->movm_stack_size += 4;
2323
2324       /* Space for a2.  */
2325       if (hash->movm_args & 0x20)
2326         hash->movm_stack_size += 4;
2327
2328       /* Space for a3.  */
2329       if (hash->movm_args & 0x10)
2330         hash->movm_stack_size += 4;
2331
2332       /* "other" space.  d0, d1, a0, a1, mdr, lir, lar, 4 byte pad.  */
2333       if (hash->movm_args & 0x08)
2334         hash->movm_stack_size += 8 * 4;
2335
2336     }
2337
2338   /* Now look for the two stack adjustment variants.  */
2339   if (byte1 == 0xf8 && byte2 == 0xfe)
2340     {
2341       int temp = bfd_get_8 (abfd, contents + addr + 2);
2342       temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2343
2344       hash->stack_size = -temp;
2345     }
2346   else if (byte1 == 0xfa && byte2 == 0xfe)
2347     {
2348       int temp = bfd_get_16 (abfd, contents + addr + 2);
2349       temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2350       temp = -temp;
2351
2352       if (temp < 255)
2353         hash->stack_size = temp;
2354     }
2355
2356   /* If the total stack to be allocated by the call instruction is more
2357      than 255 bytes, then we can't remove the stack adjustment by using
2358      "call" (we might still be able to remove the "movm" instruction.  */
2359   if (hash->stack_size + hash->movm_stack_size > 255)
2360     hash->stack_size = 0;
2361
2362   return;
2363 }
2364
2365 /* Delete some bytes from a section while relaxing.  */
2366
2367 static boolean
2368 mn10300_elf_relax_delete_bytes (abfd, sec, addr, count)
2369      bfd *abfd;
2370      asection *sec;
2371      bfd_vma addr;
2372      int count;
2373 {
2374   Elf_Internal_Shdr *symtab_hdr;
2375   Elf32_External_Sym *extsyms;
2376   int shndx, index;
2377   bfd_byte *contents;
2378   Elf_Internal_Rela *irel, *irelend;
2379   Elf_Internal_Rela *irelalign;
2380   bfd_vma toaddr;
2381   Elf32_External_Sym *esym, *esymend;
2382   struct elf32_mn10300_link_hash_entry *sym_hash;
2383
2384   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2385   extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2386
2387   shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2388
2389   contents = elf_section_data (sec)->this_hdr.contents;
2390
2391   /* The deletion must stop at the next ALIGN reloc for an aligment
2392      power larger than the number of bytes we are deleting.  */
2393
2394   irelalign = NULL;
2395   toaddr = sec->_cooked_size;
2396
2397   irel = elf_section_data (sec)->relocs;
2398   irelend = irel + sec->reloc_count;
2399
2400   /* Actually delete the bytes.  */
2401   memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2402   sec->_cooked_size -= count;
2403
2404   /* Adjust all the relocs.  */
2405   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2406     {
2407       /* Get the new reloc address.  */
2408       if ((irel->r_offset > addr
2409            && irel->r_offset < toaddr))
2410         irel->r_offset -= count;
2411     }
2412
2413   /* Adjust the local symbols defined in this section.  */
2414   esym = extsyms;
2415   esymend = esym + symtab_hdr->sh_info;
2416   for (; esym < esymend; esym++)
2417     {
2418       Elf_Internal_Sym isym;
2419
2420       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2421
2422       if (isym.st_shndx == shndx
2423           && isym.st_value > addr
2424           && isym.st_value < toaddr)
2425         {
2426           isym.st_value -= count;
2427           bfd_elf32_swap_symbol_out (abfd, &isym, esym);
2428         }
2429     }
2430
2431   /* Now adjust the global symbols defined in this section.  */
2432   esym = extsyms + symtab_hdr->sh_info;
2433   esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2434   for (index = 0; esym < esymend; esym++, index++)
2435     {
2436       Elf_Internal_Sym isym;
2437
2438       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2439       sym_hash = (struct elf32_mn10300_link_hash_entry *)
2440                    (elf_sym_hashes (abfd)[index]);
2441       if (isym.st_shndx == shndx
2442           && ((sym_hash)->root.root.type == bfd_link_hash_defined
2443               || (sym_hash)->root.root.type == bfd_link_hash_defweak)
2444           && (sym_hash)->root.root.u.def.section == sec
2445           && (sym_hash)->root.root.u.def.value > addr
2446           && (sym_hash)->root.root.u.def.value < toaddr)
2447         {
2448           (sym_hash)->root.root.u.def.value -= count;
2449         }
2450     }
2451
2452   return true;
2453 }
2454
2455 /* Return true if a symbol exists at the given address, else return
2456    false.  */
2457 static boolean
2458 mn10300_elf_symbol_address_p (abfd, sec, extsyms, addr)
2459      bfd *abfd;
2460      asection *sec;
2461      Elf32_External_Sym *extsyms;
2462      bfd_vma addr;
2463 {
2464   Elf_Internal_Shdr *symtab_hdr;
2465   int shndx;
2466   Elf32_External_Sym *esym, *esymend;
2467   struct elf32_mn10300_link_hash_entry **sym_hash, **sym_hash_end;
2468
2469   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2470   shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2471
2472   /* Examine all the symbols.  */
2473   esym = extsyms;
2474   esymend = esym + symtab_hdr->sh_info;
2475   for (; esym < esymend; esym++)
2476     {
2477       Elf_Internal_Sym isym;
2478
2479       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2480
2481       if (isym.st_shndx == shndx
2482           && isym.st_value == addr)
2483         return true;
2484     }
2485
2486   sym_hash = (struct elf32_mn10300_link_hash_entry **)(elf_sym_hashes (abfd));
2487   sym_hash_end = (sym_hash
2488                   + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2489                      - symtab_hdr->sh_info));
2490   for (; sym_hash < sym_hash_end; sym_hash++)
2491     {
2492       if (((*sym_hash)->root.root.type == bfd_link_hash_defined
2493            || (*sym_hash)->root.root.type == bfd_link_hash_defweak)
2494           && (*sym_hash)->root.root.u.def.section == sec
2495           && (*sym_hash)->root.root.u.def.value == addr)
2496         return true;
2497     }
2498   return false;
2499 }
2500
2501 /* This is a version of bfd_generic_get_relocated_section_contents
2502    which uses mn10300_elf_relocate_section.  */
2503
2504 static bfd_byte *
2505 mn10300_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
2506                                             data, relocateable, symbols)
2507      bfd *output_bfd;
2508      struct bfd_link_info *link_info;
2509      struct bfd_link_order *link_order;
2510      bfd_byte *data;
2511      boolean relocateable;
2512      asymbol **symbols;
2513 {
2514   Elf_Internal_Shdr *symtab_hdr;
2515   asection *input_section = link_order->u.indirect.section;
2516   bfd *input_bfd = input_section->owner;
2517   asection **sections = NULL;
2518   Elf_Internal_Rela *internal_relocs = NULL;
2519   Elf32_External_Sym *external_syms = NULL;
2520   Elf_Internal_Sym *internal_syms = NULL;
2521
2522   /* We only need to handle the case of relaxing, or of having a
2523      particular set of section contents, specially.  */
2524   if (relocateable
2525       || elf_section_data (input_section)->this_hdr.contents == NULL)
2526     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2527                                                        link_order, data,
2528                                                        relocateable,
2529                                                        symbols);
2530
2531   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2532
2533   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2534           input_section->_raw_size);
2535
2536   if ((input_section->flags & SEC_RELOC) != 0
2537       && input_section->reloc_count > 0)
2538     {
2539       Elf_Internal_Sym *isymp;
2540       asection **secpp;
2541       Elf32_External_Sym *esym, *esymend;
2542
2543       if (symtab_hdr->contents != NULL)
2544         external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
2545       else
2546         {
2547           external_syms = ((Elf32_External_Sym *)
2548                            bfd_malloc (symtab_hdr->sh_info
2549                                        * sizeof (Elf32_External_Sym)));
2550           if (external_syms == NULL && symtab_hdr->sh_info > 0)
2551             goto error_return;
2552           if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2553               || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
2554                             symtab_hdr->sh_info, input_bfd)
2555                   != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
2556             goto error_return;
2557         }
2558
2559       internal_relocs = (_bfd_elf32_link_read_relocs
2560                          (input_bfd, input_section, (PTR) NULL,
2561                           (Elf_Internal_Rela *) NULL, false));
2562       if (internal_relocs == NULL)
2563         goto error_return;
2564
2565       internal_syms = ((Elf_Internal_Sym *)
2566                        bfd_malloc (symtab_hdr->sh_info
2567                                    * sizeof (Elf_Internal_Sym)));
2568       if (internal_syms == NULL && symtab_hdr->sh_info > 0)
2569         goto error_return;
2570
2571       sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2572                                            * sizeof (asection *));
2573       if (sections == NULL && symtab_hdr->sh_info > 0)
2574         goto error_return;
2575
2576       isymp = internal_syms;
2577       secpp = sections;
2578       esym = external_syms;
2579       esymend = esym + symtab_hdr->sh_info;
2580       for (; esym < esymend; ++esym, ++isymp, ++secpp)
2581         {
2582           asection *isec;
2583
2584           bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
2585
2586           if (isymp->st_shndx == SHN_UNDEF)
2587             isec = bfd_und_section_ptr;
2588           else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
2589             isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2590           else if (isymp->st_shndx == SHN_ABS)
2591             isec = bfd_abs_section_ptr;
2592           else if (isymp->st_shndx == SHN_COMMON)
2593             isec = bfd_com_section_ptr;
2594           else
2595             {
2596               /* Who knows?  */
2597               isec = NULL;
2598             }
2599
2600           *secpp = isec;
2601         }
2602
2603       if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
2604                                      input_section, data, internal_relocs,
2605                                      internal_syms, sections))
2606         goto error_return;
2607
2608       if (sections != NULL)
2609         free (sections);
2610       sections = NULL;
2611       if (internal_syms != NULL)
2612         free (internal_syms);
2613       internal_syms = NULL;
2614       if (external_syms != NULL && symtab_hdr->contents == NULL)
2615         free (external_syms);
2616       external_syms = NULL;
2617       if (internal_relocs != elf_section_data (input_section)->relocs)
2618         free (internal_relocs);
2619       internal_relocs = NULL;
2620     }
2621
2622   return data;
2623
2624  error_return:
2625   if (internal_relocs != NULL
2626       && internal_relocs != elf_section_data (input_section)->relocs)
2627     free (internal_relocs);
2628   if (external_syms != NULL && symtab_hdr->contents == NULL)
2629     free (external_syms);
2630   if (internal_syms != NULL)
2631     free (internal_syms);
2632   if (sections != NULL)
2633     free (sections);
2634   return NULL;
2635 }
2636
2637 /* Assorted hash table functions.  */
2638
2639 /* Initialize an entry in the link hash table.  */
2640
2641 /* Create an entry in an MN10300 ELF linker hash table.  */
2642
2643 static struct bfd_hash_entry *
2644 elf32_mn10300_link_hash_newfunc (entry, table, string)
2645      struct bfd_hash_entry *entry;
2646      struct bfd_hash_table *table;
2647      const char *string;
2648 {
2649   struct elf32_mn10300_link_hash_entry *ret =
2650     (struct elf32_mn10300_link_hash_entry *) entry;
2651
2652   /* Allocate the structure if it has not already been allocated by a
2653      subclass.  */
2654   if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2655     ret = ((struct elf32_mn10300_link_hash_entry *)
2656            bfd_hash_allocate (table,
2657                               sizeof (struct elf32_mn10300_link_hash_entry)));
2658   if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2659     return (struct bfd_hash_entry *) ret;
2660
2661   /* Call the allocation method of the superclass.  */
2662   ret = ((struct elf32_mn10300_link_hash_entry *)
2663          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2664                                      table, string));
2665   if (ret != (struct elf32_mn10300_link_hash_entry *) NULL)
2666     {
2667       ret->direct_calls = 0;
2668       ret->stack_size = 0;
2669       ret->movm_stack_size = 0;
2670       ret->flags = 0;
2671       ret->movm_args = 0;
2672     }
2673
2674   return (struct bfd_hash_entry *) ret;
2675 }
2676
2677 /* Create an mn10300 ELF linker hash table.  */
2678
2679 static struct bfd_link_hash_table *
2680 elf32_mn10300_link_hash_table_create (abfd)
2681      bfd *abfd;
2682 {
2683   struct elf32_mn10300_link_hash_table *ret;
2684
2685   ret = ((struct elf32_mn10300_link_hash_table *)
2686          bfd_alloc (abfd, sizeof (struct elf32_mn10300_link_hash_table)));
2687   if (ret == (struct elf32_mn10300_link_hash_table *) NULL)
2688     return NULL;
2689
2690   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2691                                        elf32_mn10300_link_hash_newfunc))
2692     {
2693       bfd_release (abfd, ret);
2694       return NULL;
2695     }
2696
2697   ret->flags = 0;
2698   ret->static_hash_table
2699     = ((struct elf32_mn10300_link_hash_table *)
2700        bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
2701   if (ret->static_hash_table == NULL)
2702     {
2703       bfd_release (abfd, ret);
2704       return NULL;
2705     }
2706
2707   if (! _bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
2708                                        elf32_mn10300_link_hash_newfunc))
2709     {
2710       bfd_release (abfd, ret->static_hash_table);
2711       bfd_release (abfd, ret);
2712       return NULL;
2713     }
2714   return &ret->root.root;
2715 }
2716
2717 static int
2718 elf_mn10300_mach (flags)
2719      flagword flags;
2720 {
2721   switch (flags & EF_MN10300_MACH)
2722     {
2723       case E_MN10300_MACH_MN10300:
2724       default:
2725         return bfd_mach_mn10300;
2726
2727     }
2728 }
2729
2730 /* The final processing done just before writing out a MN10300 ELF object
2731    file.  This gets the MN10300 architecture right based on the machine
2732    number.  */
2733
2734 /*ARGSUSED*/
2735 void
2736 _bfd_mn10300_elf_final_write_processing (abfd, linker)
2737      bfd *abfd;
2738      boolean linker;
2739 {
2740   unsigned long val;
2741   unsigned int i;
2742   Elf_Internal_Shdr **hdrpp;
2743   const char *name;
2744   asection *sec;
2745
2746   switch (bfd_get_mach (abfd))
2747     {
2748       default:
2749       case bfd_mach_mn10300:
2750         val = E_MN10300_MACH_MN10300;
2751         break;
2752
2753     }
2754
2755   elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
2756   elf_elfheader (abfd)->e_flags |= val;
2757 }
2758
2759 boolean
2760 _bfd_mn10300_elf_object_p (abfd)
2761      bfd *abfd;
2762 {
2763   bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
2764                              elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
2765   return true;
2766 }
2767
2768 /* Merge backend specific data from an object file to the output
2769    object file when linking.  */
2770
2771 boolean
2772 _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
2773      bfd *ibfd;
2774      bfd *obfd;
2775 {
2776   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2777       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2778     return true;
2779
2780   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2781       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
2782     {
2783       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2784                                bfd_get_mach (ibfd)))
2785         return false;
2786     }
2787
2788   return true;
2789 }
2790
2791
2792 #define TARGET_LITTLE_SYM       bfd_elf32_mn10300_vec
2793 #define TARGET_LITTLE_NAME      "elf32-mn10300"
2794 #define ELF_ARCH                bfd_arch_mn10300
2795 #define ELF_MACHINE_CODE        EM_CYGNUS_MN10300
2796 #define ELF_MAXPAGESIZE         0x1000
2797
2798 #define elf_info_to_howto               mn10300_info_to_howto
2799 #define elf_info_to_howto_rel           0
2800 #define elf_backend_can_gc_sections     1
2801 #define elf_backend_check_relocs        mn10300_elf_check_relocs
2802 #define elf_backend_gc_mark_hook        mn10300_elf_gc_mark_hook
2803 #define elf_backend_relocate_section    mn10300_elf_relocate_section
2804 #define bfd_elf32_bfd_relax_section     mn10300_elf_relax_section
2805 #define bfd_elf32_bfd_get_relocated_section_contents \
2806                                 mn10300_elf_get_relocated_section_contents
2807 #define bfd_elf32_bfd_link_hash_table_create \
2808                                 elf32_mn10300_link_hash_table_create
2809
2810 #define elf_symbol_leading_char '_'
2811
2812 /* So we can set bits in e_flags.  */
2813 #define elf_backend_final_write_processing \
2814                                         _bfd_mn10300_elf_final_write_processing
2815 #define elf_backend_object_p            _bfd_mn10300_elf_object_p
2816
2817 #define bfd_elf32_bfd_merge_private_bfd_data \
2818                                         _bfd_mn10300_elf_merge_private_bfd_data
2819
2820
2821 #include "elf32-target.h"