bfd/elf-m10300.c

   1 /* Matsushita 10300 specific support for 32-bit ELF
   2    Copyright (C) 1996, 1997, 1998, 1999 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 ATTRIBUTE_UNUSED;
 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 ATTRIBUTE_UNUSED;
 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 ATTRIBUTE_UNUSED;
 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             default:
 412               break;
 413             }
 414         }
 415     }
 416   else
 417     {
 418       if (!(elf_bad_symtab (abfd)
 419             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
 420           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
 421                 && sym->st_shndx != SHN_COMMON))
 422         {
 423           return bfd_section_from_elf_index (abfd, sym->st_shndx);
 424         }
 425     }
 426
 427   return NULL;
 428 }
 429
 430 /* Perform a relocation as part of a final link.  */
 431 static bfd_reloc_status_type
 432 mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
 433                                  input_section, contents, offset, value,
 434                                  addend, info, sym_sec, is_local)
 435      reloc_howto_type *howto;
 436      bfd *input_bfd;
 437      bfd *output_bfd ATTRIBUTE_UNUSED;
 438      asection *input_section;
 439      bfd_byte *contents;
 440      bfd_vma offset;
 441      bfd_vma value;
 442      bfd_vma addend;
 443      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 444      asection *sym_sec ATTRIBUTE_UNUSED;
 445      int is_local ATTRIBUTE_UNUSED;
 446 {
 447   unsigned long r_type = howto->type;
 448   bfd_byte *hit_data = contents + offset;
 449
 450   switch (r_type)
 451     {
 452     case R_MN10300_NONE:
 453       return bfd_reloc_ok;
 454
 455     case R_MN10300_32:
 456       value += addend;
 457       bfd_put_32 (input_bfd, value, hit_data);
 458       return bfd_reloc_ok;
 459
 460     case R_MN10300_24:
 461       value += addend;
 462
 463       if ((long)value > 0x7fffff || (long)value < -0x800000)
 464         return bfd_reloc_overflow;
 465
 466       bfd_put_8 (input_bfd, value & 0xff, hit_data);
 467       bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
 468       bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
 469       return bfd_reloc_ok;
 470
 471     case R_MN10300_16:
 472       value += addend;
 473
 474       if ((long)value > 0x7fff || (long)value < -0x8000)
 475         return bfd_reloc_overflow;
 476
 477       bfd_put_16 (input_bfd, value, hit_data);
 478       return bfd_reloc_ok;
 479
 480     case R_MN10300_8:
 481       value += addend;
 482
 483       if ((long)value > 0x7f || (long)value < -0x80)
 484         return bfd_reloc_overflow;
 485
 486       bfd_put_8 (input_bfd, value, hit_data);
 487       return bfd_reloc_ok;
 488
 489     case R_MN10300_PCREL8:
 490       value -= (input_section->output_section->vma
 491                 + input_section->output_offset);
 492       value -= offset;
 493       value += addend;
 494
 495       if ((long)value > 0xff || (long)value < -0x100)
 496         return bfd_reloc_overflow;
 497
 498       bfd_put_8 (input_bfd, value, hit_data);
 499       return bfd_reloc_ok;
 500
 501     case R_MN10300_PCREL16:
 502       value -= (input_section->output_section->vma
 503                 + input_section->output_offset);
 504       value -= offset;
 505       value += addend;
 506
 507       if ((long)value > 0xffff || (long)value < -0x10000)
 508         return bfd_reloc_overflow;
 509
 510       bfd_put_16 (input_bfd, value, hit_data);
 511       return bfd_reloc_ok;
 512
 513     case R_MN10300_PCREL32:
 514       value -= (input_section->output_section->vma
 515                 + input_section->output_offset);
 516       value -= offset;
 517       value += addend;
 518
 519       bfd_put_32 (input_bfd, value, hit_data);
 520       return bfd_reloc_ok;
 521
 522     case R_MN10300_GNU_VTINHERIT:
 523     case R_MN10300_GNU_VTENTRY:
 524       return bfd_reloc_ok;
 525
 526     default:
 527       return bfd_reloc_notsupported;
 528     }
 529 }
 530
 531 \f
 532 /* Relocate an MN10300 ELF section.  */
 533 static boolean
 534 mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 535                               contents, relocs, local_syms, local_sections)
 536      bfd *output_bfd;
 537      struct bfd_link_info *info;
 538      bfd *input_bfd;
 539      asection *input_section;
 540      bfd_byte *contents;
 541      Elf_Internal_Rela *relocs;
 542      Elf_Internal_Sym *local_syms;
 543      asection **local_sections;
 544 {
 545   Elf_Internal_Shdr *symtab_hdr;
 546   struct elf32_mn10300_link_hash_entry **sym_hashes;
 547   Elf_Internal_Rela *rel, *relend;
 548
 549   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 550   sym_hashes = (struct elf32_mn10300_link_hash_entry **)
 551                  (elf_sym_hashes (input_bfd));
 552
 553   rel = relocs;
 554   relend = relocs + input_section->reloc_count;
 555   for (; rel < relend; rel++)
 556     {
 557       int r_type;
 558       reloc_howto_type *howto;
 559       unsigned long r_symndx;
 560       Elf_Internal_Sym *sym;
 561       asection *sec;
 562       struct elf32_mn10300_link_hash_entry *h;
 563       bfd_vma relocation;
 564       bfd_reloc_status_type r;
 565
 566       r_symndx = ELF32_R_SYM (rel->r_info);
 567       r_type = ELF32_R_TYPE (rel->r_info);
 568       howto = elf_mn10300_howto_table + r_type;
 569
 570       /* Just skip the vtable gc relocs.  */
 571       if (r_type == R_MN10300_GNU_VTINHERIT
 572           || r_type == R_MN10300_GNU_VTENTRY)
 573         continue;
 574
 575       if (info->relocateable)
 576         {
 577           /* This is a relocateable link.  We don't have to change
 578              anything, unless the reloc is against a section symbol,
 579              in which case we have to adjust according to where the
 580              section symbol winds up in the output section.  */
 581           if (r_symndx < symtab_hdr->sh_info)
 582             {
 583               sym = local_syms + r_symndx;
 584               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 585                 {
 586                   sec = local_sections[r_symndx];
 587                   rel->r_addend += sec->output_offset + sym->st_value;
 588                 }
 589             }
 590
 591           continue;
 592         }
 593
 594       /* This is a final link.  */
 595       h = NULL;
 596       sym = NULL;
 597       sec = NULL;
 598       if (r_symndx < symtab_hdr->sh_info)
 599         {
 600           sym = local_syms + r_symndx;
 601           sec = local_sections[r_symndx];
 602           relocation = (sec->output_section->vma
 603                         + sec->output_offset
 604                         + sym->st_value);
 605         }
 606       else
 607         {
 608           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 609           while (h->root.type == bfd_link_hash_indirect
 610                  || h->root.type == bfd_link_hash_warning)
 611             h = (struct elf32_mn10300_link_hash_entry *) h->root.root.u.i.link;
 612           if (h->root.root.type == bfd_link_hash_defined
 613               || h->root.root.type == bfd_link_hash_defweak)
 614             {
 615               sec = h->root.root.u.def.section;
 616               relocation = (h->root.root.u.def.value
 617                             + sec->output_section->vma
 618                             + sec->output_offset);
 619             }
 620           else if (h->root.root.type == bfd_link_hash_undefweak)
 621             relocation = 0;
 622           else
 623             {
 624               if (! ((*info->callbacks->undefined_symbol)
 625                      (info, h->root.root.root.string, input_bfd,
 626                       input_section, rel->r_offset)))
 627                 return false;
 628               relocation = 0;
 629             }
 630         }
 631
 632       r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
 633                                            input_section,
 634                                            contents, rel->r_offset,
 635                                            relocation, rel->r_addend,
 636                                            info, sec, h == NULL);
 637
 638       if (r != bfd_reloc_ok)
 639         {
 640           const char *name;
 641           const char *msg = (const char *)0;
 642
 643           if (h != NULL)
 644             name = h->root.root.root.string;
 645           else
 646             {
 647               name = (bfd_elf_string_from_elf_section
 648                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
 649               if (name == NULL || *name == '\0')
 650                 name = bfd_section_name (input_bfd, sec);
 651             }
 652
 653           switch (r)
 654             {
 655             case bfd_reloc_overflow:
 656               if (! ((*info->callbacks->reloc_overflow)
 657                      (info, name, howto->name, (bfd_vma) 0,
 658                       input_bfd, input_section, rel->r_offset)))
 659                 return false;
 660               break;
 661
 662             case bfd_reloc_undefined:
 663               if (! ((*info->callbacks->undefined_symbol)
 664                      (info, name, input_bfd, input_section,
 665                       rel->r_offset)))
 666                 return false;
 667               break;
 668
 669             case bfd_reloc_outofrange:
 670               msg = _("internal error: out of range error");
 671               goto common_error;
 672
 673             case bfd_reloc_notsupported:
 674               msg = _("internal error: unsupported relocation error");
 675               goto common_error;
 676
 677             case bfd_reloc_dangerous:
 678               msg = _("internal error: dangerous error");
 679               goto common_error;
 680
 681             default:
 682               msg = _("internal error: unknown error");
 683               /* fall through */
 684
 685             common_error:
 686               if (!((*info->callbacks->warning)
 687                     (info, msg, name, input_bfd, input_section,
 688                      rel->r_offset)))
 689                 return false;
 690               break;
 691             }
 692         }
 693     }
 694
 695   return true;
 696 }
 697
 698 /* Finish initializing one hash table entry.  */
 699 static boolean
 700 elf32_mn10300_finish_hash_table_entry (gen_entry, in_args)
 701      struct bfd_hash_entry *gen_entry;
 702      PTR in_args ATTRIBUTE_UNUSED;
 703 {
 704   struct elf32_mn10300_link_hash_entry *entry;
 705   unsigned int byte_count = 0;
 706
 707   entry = (struct elf32_mn10300_link_hash_entry *)gen_entry;
 708
 709   /* If we already know we want to convert "call" to "calls" for calls
 710      to this symbol, then return now.  */
 711   if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
 712     return true;
 713
 714   /* If there are no named calls to this symbol, or there's nothing we
 715      can move from the function itself into the "call" instruction, then
 716      note that all "call" instructions should be converted into "calls"
 717      instructions and return.  */
 718   if (entry->direct_calls == 0
 719       || (entry->stack_size == 0 && entry->movm_args == 0))
 720     {
 721       /* Make a note that we should convert "call" instructions to "calls"
 722          instructions for calls to this symbol.  */
 723       entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
 724       return true;
 725     }
 726
 727   /* We may be able to move some instructions from the function itself into
 728      the "call" instruction.  Count how many bytes we might be able to
 729      eliminate in the function itself.  */
 730
 731   /* A movm instruction is two bytes.  */
 732   if (entry->movm_args)
 733     byte_count += 2;
 734
 735   /* Count the insn to allocate stack space too.  */
 736   if (entry->stack_size > 0 && entry->stack_size <= 128)
 737     byte_count += 3;
 738   else if (entry->stack_size > 0 && entry->stack_size < 256)
 739     byte_count += 4;
 740
 741   /* If using "call" will result in larger code, then turn all
 742      the associated "call" instructions into "calls" instrutions.  */
 743   if (byte_count < entry->direct_calls)
 744     entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
 745
 746   /* This routine never fails.  */
 747   return true;
 748 }
 749
 750 /* This function handles relaxing for the mn10300.
 751
 752    There's quite a few relaxing opportunites available on the mn10300:
 753
 754         * calls:32 -> calls:16                                     2 bytes
 755         * call:32  -> call:16                                      2 bytes
 756
 757         * call:32 -> calls:32                                      1 byte
 758         * call:16 -> calls:16                                      1 byte
 759                 * These are done anytime using "calls" would result
 760                 in smaller code, or when necessary to preserve the
 761                 meaning of the program.
 762
 763         * call:32                                                  varies
 764         * call:16
 765                 * In some circumstances we can move instructions
 766                 from a function prologue into a "call" instruction.
 767                 This is only done if the resulting code is no larger
 768                 than the original code.
 769
 770
 771         * jmp:32 -> jmp:16                                         2 bytes
 772         * jmp:16 -> bra:8                                          1 byte
 773
 774                 * If the previous instruction is a conditional branch
 775                 around the jump/bra, we may be able to reverse its condition
 776                 and change its target to the jump's target.  The jump/bra
 777                 can then be deleted.                               2 bytes
 778
 779         * mov abs32 -> mov abs16                                   1 or 2 bytes
 780
 781         * Most instructions which accept imm32 can relax to imm16  1 or 2 bytes
 782         - Most instructions which accept imm16 can relax to imm8   1 or 2 bytes
 783
 784         * Most instructions which accept d32 can relax to d16      1 or 2 bytes
 785         - Most instructions which accept d16 can relax to d8       1 or 2 bytes
 786
 787         We don't handle imm16->imm8 or d16->d8 as they're very rare
 788         and somewhat more difficult to support.  */
 789
 790 static boolean
 791 mn10300_elf_relax_section (abfd, sec, link_info, again)
 792      bfd *abfd;
 793      asection *sec;
 794      struct bfd_link_info *link_info;
 795      boolean *again;
 796 {
 797   Elf_Internal_Shdr *symtab_hdr;
 798   Elf_Internal_Rela *internal_relocs = NULL;
 799   Elf_Internal_Rela *free_relocs = NULL;
 800   Elf_Internal_Rela *irel, *irelend;
 801   bfd_byte *contents = NULL;
 802   bfd_byte *free_contents = NULL;
 803   Elf32_External_Sym *extsyms = NULL;
 804   Elf32_External_Sym *free_extsyms = NULL;
 805   struct elf32_mn10300_link_hash_table *hash_table;
 806
 807   /* Assume nothing changes.  */
 808   *again = false;
 809
 810   /* We need a pointer to the mn10300 specific hash table.  */
 811   hash_table = elf32_mn10300_hash_table (link_info);
 812
 813   /* Initialize fields in each hash table entry the first time through.  */
 814   if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
 815     {
 816       bfd *input_bfd;
 817
 818       /* Iterate over all the input bfds.  */
 819       for (input_bfd = link_info->input_bfds;
 820            input_bfd != NULL;
 821            input_bfd = input_bfd->link_next)
 822         {
 823           asection *section;
 824
 825           /* We're going to need all the symbols for each bfd.  */
 826           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 827
 828           /* Get cached copy if it exists.  */
 829           if (symtab_hdr->contents != NULL)
 830             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
 831           else
 832             {
 833               /* Go get them off disk.  */
 834               extsyms = ((Elf32_External_Sym *)
 835                          bfd_malloc (symtab_hdr->sh_size));
 836               if (extsyms == NULL)
 837                 goto error_return;
 838               free_extsyms = extsyms;
 839               if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
 840                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
 841                       != symtab_hdr->sh_size))
 842                 goto error_return;
 843             }
 844
 845           /* Iterate over each section in this bfd.  */
 846           for (section = input_bfd->sections;
 847                section != NULL;
 848                section = section->next)
 849             {
 850               struct elf32_mn10300_link_hash_entry *hash;
 851               Elf_Internal_Sym *sym;
 852               asection *sym_sec;
 853               const char *sym_name;
 854               char *new_name;
 855
 856               /* Get cached copy of section contents if it exists.  */
 857               if (elf_section_data (section)->this_hdr.contents != NULL)
 858                 contents = elf_section_data (section)->this_hdr.contents;
 859               else if (section->_raw_size != 0)
 860                 {
 861                   /* Go get them off disk.  */
 862                   contents = (bfd_byte *)bfd_malloc (section->_raw_size);
 863                   if (contents == NULL)
 864                     goto error_return;
 865                   free_contents = contents;
 866
 867                   if (!bfd_get_section_contents (input_bfd, section,
 868                                                  contents, (file_ptr) 0,
 869                                                  section->_raw_size))
 870                     goto error_return;
 871                 }
 872               else
 873                 {
 874                   contents = NULL;
 875                   free_contents = NULL;
 876                 }
 877
 878               /* If there aren't any relocs, then there's nothing to do.  */
 879               if ((section->flags & SEC_RELOC) != 0
 880                   && section->reloc_count != 0)
 881                 {
 882
 883                   /* Get a copy of the native relocations.  */
 884                   internal_relocs = (_bfd_elf32_link_read_relocs
 885                                      (input_bfd, section, (PTR) NULL,
 886                                       (Elf_Internal_Rela *) NULL,
 887                                       link_info->keep_memory));
 888                   if (internal_relocs == NULL)
 889                     goto error_return;
 890                   if (! link_info->keep_memory)
 891                     free_relocs = internal_relocs;
 892
 893                   /* Now examine each relocation.  */
 894                   irel = internal_relocs;
 895                   irelend = irel + section->reloc_count;
 896                   for (; irel < irelend; irel++)
 897                     {
 898                       long r_type;
 899                       unsigned long r_index;
 900                       unsigned char code;
 901
 902                       r_type = ELF32_R_TYPE (irel->r_info);
 903                       r_index = ELF32_R_SYM (irel->r_info);
 904
 905                       if (r_type < 0 || r_type >= (int)R_MN10300_MAX)
 906                         goto error_return;
 907
 908                       /* We need the name and hash table entry of the target
 909                          symbol!  */
 910                       hash = NULL;
 911                       sym = NULL;
 912                       sym_sec = NULL;
 913
 914                       if (r_index < symtab_hdr->sh_info)
 915                         {
 916                           /* A local symbol.  */
 917                           Elf_Internal_Sym isym;
 918
 919                           bfd_elf32_swap_symbol_in (input_bfd,
 920                                                     extsyms + r_index, &isym);
 921
 922                           if (isym.st_shndx == SHN_UNDEF)
 923                             sym_sec = bfd_und_section_ptr;
 924                           else if (isym.st_shndx > 0
 925                                    && isym.st_shndx < SHN_LORESERVE)
 926                             sym_sec
 927                               = bfd_section_from_elf_index (input_bfd,
 928                                                             isym.st_shndx);
 929                           else if (isym.st_shndx == SHN_ABS)
 930                             sym_sec = bfd_abs_section_ptr;
 931                           else if (isym.st_shndx == SHN_COMMON)
 932                             sym_sec = bfd_com_section_ptr;
 933
 934                           sym_name = bfd_elf_string_from_elf_section (input_bfd,
 935                                                            symtab_hdr->sh_link,
 936                                                            isym.st_name);
 937
 938                           /* If it isn't a function, then we don't care
 939                              about it.  */
 940                           if (r_index < symtab_hdr->sh_info
 941                               && ELF_ST_TYPE (isym.st_info) != STT_FUNC)
 942                             continue;
 943
 944                           /* Tack on an ID so we can uniquely identify this
 945                              local symbol in the global hash table.  */
 946                           new_name = bfd_malloc (strlen (sym_name) + 10);
 947                           if (new_name == 0)
 948                             goto error_return;
 949
 950                           sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
 951                           sym_name = new_name;
 952
 953                           hash = (struct elf32_mn10300_link_hash_entry *)
 954                                    elf_link_hash_lookup (&hash_table->static_hash_table->root,
 955                                                          sym_name, true,
 956                                                          true, false);
 957                           free (new_name);
 958                         }
 959                       else
 960                         {
 961                           r_index -= symtab_hdr->sh_info;
 962                           hash = (struct elf32_mn10300_link_hash_entry *)
 963                                    elf_sym_hashes (input_bfd)[r_index];
 964                         }
 965
 966                       /* If this is not a "call" instruction, then we
 967                          should convert "call" instructions to "calls"
 968                          instructions.  */
 969                       code = bfd_get_8 (input_bfd,
 970                                         contents + irel->r_offset - 1);
 971                       if (code != 0xdd && code != 0xcd)
 972                         hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
 973
 974                       /* If this is a jump/call, then bump the direct_calls
 975                          counter.  Else force "call" to "calls" conversions.  */
 976                       if (r_type == R_MN10300_PCREL32
 977                           || r_type == R_MN10300_PCREL16)
 978                         hash->direct_calls++;
 979                       else
 980                         hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
 981                     }
 982                 }
 983
 984               /* Now look at the actual contents to get the stack size,
 985                  and a list of what registers were saved in the prologue
 986                  (ie movm_args).  */
 987               if ((section->flags & SEC_CODE) != 0)
 988                 {
 989
 990                   Elf32_External_Sym *esym, *esymend;
 991                   int idx, shndx;
 992
 993                   shndx = _bfd_elf_section_from_bfd_section (input_bfd,
 994                                                              section);
 995
 996
 997                   /* Look at each function defined in this section and
 998                      update info for that function.  */
 999                   esym = extsyms;
1000                   esymend = esym + symtab_hdr->sh_info;
1001                   for (; esym < esymend; esym++)
1002                     {
1003                       Elf_Internal_Sym isym;
1004
1005                       bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1006                       if (isym.st_shndx == shndx
1007                           && ELF_ST_TYPE (isym.st_info) == STT_FUNC)
1008                         {
1009                           if (isym.st_shndx == SHN_UNDEF)
1010                             sym_sec = bfd_und_section_ptr;
1011                           else if (isym.st_shndx > 0
1012                                    && isym.st_shndx < SHN_LORESERVE)
1013                             sym_sec
1014                               = bfd_section_from_elf_index (input_bfd,
1015                                                             isym.st_shndx);
1016                           else if (isym.st_shndx == SHN_ABS)
1017                             sym_sec = bfd_abs_section_ptr;
1018                           else if (isym.st_shndx == SHN_COMMON)
1019                             sym_sec = bfd_com_section_ptr;
1020
1021                           sym_name = bfd_elf_string_from_elf_section (input_bfd,
1022                                                         symtab_hdr->sh_link,
1023                                                         isym.st_name);
1024
1025                           /* Tack on an ID so we can uniquely identify this
1026                              local symbol in the global hash table.  */
1027                           new_name = bfd_malloc (strlen (sym_name) + 10);
1028                           if (new_name == 0)
1029                             goto error_return;
1030
1031                           sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1032                           sym_name = new_name;
1033
1034                           hash = (struct elf32_mn10300_link_hash_entry *)
1035                                     elf_link_hash_lookup (&hash_table->static_hash_table->root,
1036                                                           sym_name, true,
1037                                                           true, false);
1038                           free (new_name);
1039                           compute_function_info (input_bfd, hash,
1040                                                  isym.st_value, contents);
1041                         }
1042                     }
1043
1044                   esym = extsyms + symtab_hdr->sh_info;
1045                   esymend = extsyms + (symtab_hdr->sh_size
1046                                        / sizeof (Elf32_External_Sym));
1047                   for (idx = 0; esym < esymend; esym++, idx++)
1048                     {
1049                       Elf_Internal_Sym isym;
1050
1051                       bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1052                       hash = (struct elf32_mn10300_link_hash_entry *)
1053                                elf_sym_hashes (input_bfd)[idx];
1054                       if (isym.st_shndx == shndx
1055                           && ELF_ST_TYPE (isym.st_info) == STT_FUNC
1056                           && (hash)->root.root.u.def.section == section
1057                           && ((hash)->root.root.type == bfd_link_hash_defined
1058                               || (hash)->root.root.type == bfd_link_hash_defweak))
1059                         compute_function_info (input_bfd, hash,
1060                                                (hash)->root.root.u.def.value,
1061                                                contents);
1062                     }
1063                 }
1064
1065               /* Cache or free any memory we allocated for the relocs.  */
1066               if (free_relocs != NULL)
1067                 {
1068                   free (free_relocs);
1069                   free_relocs = NULL;
1070                 }
1071
1072               /* Cache or free any memory we allocated for the contents.  */
1073               if (free_contents != NULL)
1074                 {
1075                   if (! link_info->keep_memory)
1076                     free (free_contents);
1077                   else
1078                     {
1079                       /* Cache the section contents for elf_link_input_bfd.  */
1080                       elf_section_data (section)->this_hdr.contents = contents;
1081                     }
1082                   free_contents = NULL;
1083                 }
1084             }
1085
1086           /* Cache or free any memory we allocated for the symbols.  */
1087           if (free_extsyms != NULL)
1088             {
1089               if (! link_info->keep_memory)
1090                 free (free_extsyms);
1091               else
1092                 {
1093                   /* Cache the symbols for elf_link_input_bfd.  */
1094                   symtab_hdr->contents = extsyms;
1095                 }
1096               free_extsyms = NULL;
1097             }
1098         }
1099
1100       /* Now iterate on each symbol in the hash table and perform
1101          the final initialization steps on each.  */
1102       elf32_mn10300_link_hash_traverse (hash_table,
1103                                         elf32_mn10300_finish_hash_table_entry,
1104                                         NULL);
1105       elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
1106                                         elf32_mn10300_finish_hash_table_entry,
1107                                         NULL);
1108
1109       /* All entries in the hash table are fully initialized.  */
1110       hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
1111
1112       /* Now that everything has been initialized, go through each
1113          code section and delete any prologue insns which will be
1114          redundant because their operations will be performed by
1115          a "call" instruction.  */
1116       for (input_bfd = link_info->input_bfds;
1117            input_bfd != NULL;
1118            input_bfd = input_bfd->link_next)
1119         {
1120           asection *section;
1121
1122           /* We're going to need all the symbols for each bfd.  */
1123           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1124
1125           /* Get cached copy if it exists.  */
1126           if (symtab_hdr->contents != NULL)
1127             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1128           else
1129             {
1130               /* Go get them off disk.  */
1131               extsyms = ((Elf32_External_Sym *)
1132                          bfd_malloc (symtab_hdr->sh_size));
1133               if (extsyms == NULL)
1134                 goto error_return;
1135               free_extsyms = extsyms;
1136               if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1137                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
1138                       != symtab_hdr->sh_size))
1139                 goto error_return;
1140             }
1141
1142           /* Walk over each section in this bfd.  */
1143           for (section = input_bfd->sections;
1144                section != NULL;
1145                section = section->next)
1146             {
1147               int shndx;
1148               Elf32_External_Sym *esym, *esymend;
1149               int idx;
1150
1151               /* Skip non-code sections and empty sections.  */
1152               if ((section->flags & SEC_CODE) == 0 || section->_raw_size == 0)
1153                 continue;
1154
1155               if (section->reloc_count != 0)
1156                 {
1157                   /* Get a copy of the native relocations.  */
1158                   internal_relocs = (_bfd_elf32_link_read_relocs
1159                                      (input_bfd, section, (PTR) NULL,
1160                                       (Elf_Internal_Rela *) NULL,
1161                                       link_info->keep_memory));
1162                   if (internal_relocs == NULL)
1163                     goto error_return;
1164                   if (! link_info->keep_memory)
1165                     free_relocs = internal_relocs;
1166                 }
1167
1168               /* Get cached copy of section contents if it exists.  */
1169               if (elf_section_data (section)->this_hdr.contents != NULL)
1170                 contents = elf_section_data (section)->this_hdr.contents;
1171               else
1172                 {
1173                   /* Go get them off disk.  */
1174                   contents = (bfd_byte *)bfd_malloc (section->_raw_size);
1175                   if (contents == NULL)
1176                     goto error_return;
1177                   free_contents = contents;
1178
1179                   if (!bfd_get_section_contents (input_bfd, section,
1180                                                  contents, (file_ptr) 0,
1181                                                  section->_raw_size))
1182                     goto error_return;
1183                 }
1184
1185
1186               shndx = _bfd_elf_section_from_bfd_section (input_bfd, section);
1187
1188               /* Now look for any function in this section which needs
1189                  insns deleted from its prologue.  */
1190               esym = extsyms;
1191               esymend = esym + symtab_hdr->sh_info;
1192               for (; esym < esymend; esym++)
1193                 {
1194                   Elf_Internal_Sym isym;
1195                   struct elf32_mn10300_link_hash_entry *sym_hash;
1196                   asection *sym_sec;
1197                   const char *sym_name;
1198                   char *new_name;
1199
1200                   bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1201
1202                   if (isym.st_shndx != shndx)
1203                     continue;
1204
1205                   if (isym.st_shndx == SHN_UNDEF)
1206                     sym_sec = bfd_und_section_ptr;
1207                   else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1208                     sym_sec
1209                       = bfd_section_from_elf_index (input_bfd, isym.st_shndx);
1210                   else if (isym.st_shndx == SHN_ABS)
1211                     sym_sec = bfd_abs_section_ptr;
1212                   else if (isym.st_shndx == SHN_COMMON)
1213                     sym_sec = bfd_com_section_ptr;
1214
1215                   sym_name = bfd_elf_string_from_elf_section (input_bfd,
1216                                                         symtab_hdr->sh_link,
1217                                                         isym.st_name);
1218
1219                   /* Tack on an ID so we can uniquely identify this
1220                      local symbol in the global hash table.  */
1221                   new_name = bfd_malloc (strlen (sym_name) + 10);
1222                   if (new_name == 0)
1223                     goto error_return;
1224                   sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1225                   sym_name = new_name;
1226
1227                   sym_hash = (struct elf32_mn10300_link_hash_entry *)
1228                             elf_link_hash_lookup (&hash_table->static_hash_table->root,
1229                                                   sym_name, false,
1230                                                   false, false);
1231
1232                   free (new_name);
1233                   if (sym_hash == NULL)
1234                     continue;
1235
1236                   if (! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1237                       && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1238                     {
1239                       int bytes = 0;
1240
1241                       /* Note that we've changed things.  */
1242                       elf_section_data (section)->relocs = internal_relocs;
1243                       free_relocs = NULL;
1244
1245                       elf_section_data (section)->this_hdr.contents = contents;
1246                       free_contents = NULL;
1247
1248                       symtab_hdr->contents = (bfd_byte *)extsyms;
1249                       free_extsyms = NULL;
1250
1251                       /* Count how many bytes we're going to delete.  */
1252                       if (sym_hash->movm_args)
1253                         bytes += 2;
1254
1255                       if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1256                         bytes += 3;
1257                       else if (sym_hash->stack_size
1258                                && sym_hash->stack_size < 256)
1259                         bytes += 4;
1260
1261                       /* Note that we've deleted prologue bytes for this
1262                          function.  */
1263                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1264
1265                       /* Actually delete the bytes.  */
1266                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
1267                                                            section,
1268                                                            isym.st_value,
1269                                                            bytes))
1270                         goto error_return;
1271
1272                       /* Something changed.  Not strictly necessary, but
1273                          may lead to more relaxing opportunities.  */
1274                       *again = true;
1275                     }
1276                 }
1277
1278               /* Look for any global functions in this section which
1279                  need insns deleted from their prologues.  */
1280               esym = extsyms + symtab_hdr->sh_info;
1281               esymend = extsyms + (symtab_hdr->sh_size
1282                                    / sizeof (Elf32_External_Sym));
1283               for (idx = 0; esym < esymend; esym++, idx++)
1284                 {
1285                   Elf_Internal_Sym isym;
1286                   struct elf32_mn10300_link_hash_entry *sym_hash;
1287
1288                   bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1289                   sym_hash = (struct elf32_mn10300_link_hash_entry *)
1290                                (elf_sym_hashes (input_bfd)[idx]);
1291                   if (isym.st_shndx == shndx
1292                       && (sym_hash)->root.root.u.def.section == section
1293                       && ! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1294                       && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1295                     {
1296                       int bytes = 0;
1297
1298                       /* Note that we've changed things.  */
1299                       elf_section_data (section)->relocs = internal_relocs;
1300                       free_relocs = NULL;
1301
1302                       elf_section_data (section)->this_hdr.contents = contents;
1303                       free_contents = NULL;
1304
1305                       symtab_hdr->contents = (bfd_byte *)extsyms;
1306                       free_extsyms = NULL;
1307
1308                       /* Count how many bytes we're going to delete.  */
1309                       if (sym_hash->movm_args)
1310                         bytes += 2;
1311
1312                       if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1313                         bytes += 3;
1314                       else if (sym_hash->stack_size
1315                                && sym_hash->stack_size < 256)
1316                         bytes += 4;
1317
1318                       /* Note that we've deleted prologue bytes for this
1319                          function.  */
1320                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1321
1322                       /* Actually delete the bytes.  */
1323                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
1324                                                            section,
1325                                                            (sym_hash)->root.root.u.def.value,
1326                                                            bytes))
1327                         goto error_return;
1328
1329                       /* Something changed.  Not strictly necessary, but
1330                          may lead to more relaxing opportunities.  */
1331                       *again = true;
1332                     }
1333                 }
1334
1335               /* Cache or free any memory we allocated for the relocs.  */
1336               if (free_relocs != NULL)
1337                 {
1338                   free (free_relocs);
1339                   free_relocs = NULL;
1340                 }
1341
1342               /* Cache or free any memory we allocated for the contents.  */
1343               if (free_contents != NULL)
1344                 {
1345                   if (! link_info->keep_memory)
1346                     free (free_contents);
1347                   else
1348                     {
1349                       /* Cache the section contents for elf_link_input_bfd.  */
1350                       elf_section_data (section)->this_hdr.contents = contents;
1351                     }
1352                   free_contents = NULL;
1353                 }
1354             }
1355
1356           /* Cache or free any memory we allocated for the symbols.  */
1357           if (free_extsyms != NULL)
1358             {
1359               if (! link_info->keep_memory)
1360                 free (free_extsyms);
1361               else
1362                 {
1363                   /* Cache the symbols for elf_link_input_bfd.  */
1364                   symtab_hdr->contents = extsyms;
1365                 }
1366               free_extsyms = NULL;
1367             }
1368         }
1369     }
1370
1371
1372   /* (Re)initialize for the basic instruction shortening/relaxing pass.  */
1373   contents = NULL;
1374   extsyms = NULL;
1375   internal_relocs = NULL;
1376   free_relocs = NULL;
1377   free_contents = NULL;
1378   free_extsyms = NULL;
1379
1380   /* We don't have to do anything for a relocateable link, if
1381      this section does not have relocs, or if this is not a
1382      code section.  */
1383   if (link_info->relocateable
1384       || (sec->flags & SEC_RELOC) == 0
1385       || sec->reloc_count == 0
1386       || (sec->flags & SEC_CODE) == 0)
1387     return true;
1388
1389   /* If this is the first time we have been called for this section,
1390      initialize the cooked size.  */
1391   if (sec->_cooked_size == 0)
1392     sec->_cooked_size = sec->_raw_size;
1393
1394   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1395
1396   /* Get a copy of the native relocations.  */
1397   internal_relocs = (_bfd_elf32_link_read_relocs
1398                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1399                       link_info->keep_memory));
1400   if (internal_relocs == NULL)
1401     goto error_return;
1402   if (! link_info->keep_memory)
1403     free_relocs = internal_relocs;
1404
1405   /* Walk through them looking for relaxing opportunities.  */
1406   irelend = internal_relocs + sec->reloc_count;
1407   for (irel = internal_relocs; irel < irelend; irel++)
1408     {
1409       bfd_vma symval;
1410       struct elf32_mn10300_link_hash_entry *h = NULL;
1411
1412       /* If this isn't something that can be relaxed, then ignore
1413          this reloc.  */
1414       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
1415           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
1416           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
1417         continue;
1418
1419       /* Get the section contents if we haven't done so already.  */
1420       if (contents == NULL)
1421         {
1422           /* Get cached copy if it exists.  */
1423           if (elf_section_data (sec)->this_hdr.contents != NULL)
1424             contents = elf_section_data (sec)->this_hdr.contents;
1425           else
1426             {
1427               /* Go get them off disk.  */
1428               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1429               if (contents == NULL)
1430                 goto error_return;
1431               free_contents = contents;
1432
1433               if (! bfd_get_section_contents (abfd, sec, contents,
1434                                               (file_ptr) 0, sec->_raw_size))
1435                 goto error_return;
1436             }
1437         }
1438
1439       /* Read this BFD's symbols if we haven't done so already.  */
1440       if (extsyms == NULL)
1441         {
1442           /* Get cached copy if it exists.  */
1443           if (symtab_hdr->contents != NULL)
1444             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1445           else
1446             {
1447               /* Go get them off disk.  */
1448               extsyms = ((Elf32_External_Sym *)
1449                          bfd_malloc (symtab_hdr->sh_size));
1450               if (extsyms == NULL)
1451                 goto error_return;
1452               free_extsyms = extsyms;
1453               if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1454                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1455                       != symtab_hdr->sh_size))
1456                 goto error_return;
1457             }
1458         }
1459
1460       /* Get the value of the symbol referred to by the reloc.  */
1461       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1462         {
1463           Elf_Internal_Sym isym;
1464           asection *sym_sec;
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       /* Try to turn a 24 immediate, displacement or absolute address
1907          into a 8 immediate, displacement or absolute address.  */
1908       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
1909         {
1910           bfd_vma value = symval;
1911           value += irel->r_addend;
1912
1913           /* See if the value will fit in 8 bits.  */
1914           if ((long)value < 0x7f && (long)value > -0x80)
1915             {
1916               unsigned char code;
1917
1918               /* AM33 insns which have 24 operands are 6 bytes long and
1919                  will have 0xfd as the first byte.  */
1920
1921               /* Get the first opcode.  */
1922               code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1923
1924               if (code == 0xfd)
1925                 {
1926                   /* Get the second opcode.  */
1927                   code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1928
1929                   /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
1930                      equivalent instructions exists.  */
1931                   if (code != 0x6b && code != 0x7b
1932                       && code != 0x8b && code != 0x9b
1933                       && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
1934                           || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
1935                           || (code & 0x0f) == 0x0e))
1936                     {
1937                       /* Not safe if the high bit is on as relaxing may
1938                          move the value out of high mem and thus not fit
1939                          in a signed 8bit value.  This is currently over
1940                          conservative.  */
1941                       if ((value & 0x80) == 0)
1942                         {
1943                           /* Note that we've changed the relocation contents,
1944                              etc.  */
1945                           elf_section_data (sec)->relocs = internal_relocs;
1946                           free_relocs = NULL;
1947
1948                           elf_section_data (sec)->this_hdr.contents = contents;
1949                           free_contents = NULL;
1950
1951                           symtab_hdr->contents = (bfd_byte *) extsyms;
1952                           free_extsyms = NULL;
1953
1954                           /* Fix the opcode.  */
1955                           bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
1956                           bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1957
1958                           /* Fix the relocation's type.  */
1959                           irel->r_info
1960                             = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1961                                                          R_MN10300_8);
1962
1963                           /* Delete two bytes of data.  */
1964                           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1965                                                                irel->r_offset + 1, 2))
1966                             goto error_return;
1967
1968                           /* That will change things, so, we should relax
1969                              again.  Note that this is not required, and it
1970                               may be slow.  */
1971                           *again = true;
1972                           break;
1973                         }
1974                     }
1975
1976                 }
1977             }
1978         }
1979
1980       /* Try to turn a 32bit immediate, displacement or absolute address
1981          into a 16bit immediate, displacement or absolute address.  */
1982       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32)
1983         {
1984           bfd_vma value = symval;
1985           value += irel->r_addend;
1986
1987           /* See if the value will fit in 24 bits.
1988              We allow any 16bit match here.  We prune those we can't
1989              handle below.  */
1990           if ((long)value < 0x7fffff && (long)value > -0x800000)
1991             {
1992               unsigned char code;
1993
1994               /* AM33 insns which have 32bit operands are 7 bytes long and
1995                  will have 0xfe as the first byte.  */
1996
1997               /* Get the first opcode.  */
1998               code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1999
2000               if (code == 0xfe)
2001                 {
2002                   /* Get the second opcode.  */
2003                   code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
2004
2005                   /* All the am33 32 -> 24 relaxing possibilities.  */
2006                   /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
2007                      equivalent instructions exists.  */
2008                   if (code != 0x6b && code != 0x7b
2009                       && code != 0x8b && code != 0x9b
2010                       && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
2011                           || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
2012                           || (code & 0x0f) == 0x0e))
2013                     {
2014                       /* Not safe if the high bit is on as relaxing may
2015                          move the value out of high mem and thus not fit
2016                          in a signed 16bit value.  This is currently over
2017                          conservative.  */
2018                       if ((value & 0x8000) == 0)
2019                         {
2020                           /* Note that we've changed the relocation contents,
2021                              etc.  */
2022                           elf_section_data (sec)->relocs = internal_relocs;
2023                           free_relocs = NULL;
2024
2025                           elf_section_data (sec)->this_hdr.contents = contents;
2026                           free_contents = NULL;
2027
2028                           symtab_hdr->contents = (bfd_byte *) extsyms;
2029                           free_extsyms = NULL;
2030
2031                           /* Fix the opcode.  */
2032                           bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
2033                           bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2034
2035                           /* Fix the relocation's type.  */
2036                           irel->r_info
2037                             = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2038                                                          R_MN10300_24);
2039
2040                           /* Delete one byte of data.  */
2041                           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2042                                                                irel->r_offset + 3, 1))
2043                             goto error_return;
2044
2045                           /* That will change things, so, we should relax
2046                              again.  Note that this is not required, and it
2047                               may be slow.  */
2048                           *again = true;
2049                           break;
2050                         }
2051                     }
2052
2053                 }
2054             }
2055
2056           /* See if the value will fit in 16 bits.
2057              We allow any 16bit match here.  We prune those we can't
2058              handle below.  */
2059           if ((long)value < 0x7fff && (long)value > -0x8000)
2060             {
2061               unsigned char code;
2062
2063               /* Most insns which have 32bit operands are 6 bytes long;
2064                  exceptions are pcrel insns and bit insns.
2065
2066                  We handle pcrel insns above.  We don't bother trying
2067                  to handle the bit insns here.
2068
2069                  The first byte of the remaining insns will be 0xfc.  */
2070
2071               /* Get the first opcode.  */
2072               code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
2073
2074               if (code != 0xfc)
2075                 continue;
2076
2077               /* Get the second opcode.  */
2078               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2079
2080               if ((code & 0xf0) < 0x80)
2081                 switch (code & 0xf0)
2082                   {
2083                   /* mov (d32,am),dn   -> mov (d32,am),dn
2084                      mov dm,(d32,am)   -> mov dn,(d32,am)
2085                      mov (d32,am),an   -> mov (d32,am),an
2086                      mov dm,(d32,am)   -> mov dn,(d32,am)
2087                      movbu (d32,am),dn -> movbu (d32,am),dn
2088                      movbu dm,(d32,am) -> movbu dn,(d32,am)
2089                      movhu (d32,am),dn -> movhu (d32,am),dn
2090                      movhu dm,(d32,am) -> movhu dn,(d32,am) */
2091                   case 0x00:
2092                   case 0x10:
2093                   case 0x20:
2094                   case 0x30:
2095                   case 0x40:
2096                   case 0x50:
2097                   case 0x60:
2098                   case 0x70:
2099                     /* Not safe if the high bit is on as relaxing may
2100                        move the value out of high mem and thus not fit
2101                        in a signed 16bit value.  */
2102                     if (code == 0xcc
2103                         && (value & 0x8000))
2104                       continue;
2105
2106                     /* Note that we've changed the relocation contents, etc.  */
2107                     elf_section_data (sec)->relocs = internal_relocs;
2108                     free_relocs = NULL;
2109
2110                     elf_section_data (sec)->this_hdr.contents = contents;
2111                     free_contents = NULL;
2112
2113                     symtab_hdr->contents = (bfd_byte *) extsyms;
2114                     free_extsyms = NULL;
2115
2116                     /* Fix the opcode.  */
2117                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2118                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2119
2120                     /* Fix the relocation's type.  */
2121                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2122                                                  R_MN10300_16);
2123
2124                     /* Delete two bytes of data.  */
2125                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2126                                                          irel->r_offset + 2, 2))
2127                       goto error_return;
2128
2129                     /* That will change things, so, we should relax again.
2130                        Note that this is not required, and it may be slow.  */
2131                     *again = true;
2132                     break;
2133                   }
2134               else if ((code & 0xf0) == 0x80
2135                        || (code & 0xf0) == 0x90)
2136                 switch (code & 0xf3)
2137                   {
2138                   /* mov dn,(abs32)   -> mov dn,(abs16)
2139                      movbu dn,(abs32) -> movbu dn,(abs16)
2140                      movhu dn,(abs32) -> movhu dn,(abs16)  */
2141                   case 0x81:
2142                   case 0x82:
2143                   case 0x83:
2144                     /* Note that we've changed the relocation contents, etc.  */
2145                     elf_section_data (sec)->relocs = internal_relocs;
2146                     free_relocs = NULL;
2147
2148                     elf_section_data (sec)->this_hdr.contents = contents;
2149                     free_contents = NULL;
2150
2151                     symtab_hdr->contents = (bfd_byte *) extsyms;
2152                     free_extsyms = NULL;
2153
2154                     if ((code & 0xf3) == 0x81)
2155                       code = 0x01 + (code & 0x0c);
2156                     else if ((code & 0xf3) == 0x82)
2157                       code = 0x02 + (code & 0x0c);
2158                     else if ((code & 0xf3) == 0x83)
2159                       code = 0x03 + (code & 0x0c);
2160                     else
2161                       abort ();
2162
2163                     /* Fix the opcode.  */
2164                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2165
2166                     /* Fix the relocation's type.  */
2167                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2168                                                  R_MN10300_16);
2169
2170                     /* The opcode got shorter too, so we have to fix the
2171                        addend and offset too!  */
2172                     irel->r_offset -= 1;
2173
2174                     /* Delete three bytes of data.  */
2175                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2176                                                          irel->r_offset + 1, 3))
2177                       goto error_return;
2178
2179                     /* That will change things, so, we should relax again.
2180                        Note that this is not required, and it may be slow.  */
2181                     *again = true;
2182                     break;
2183
2184                   /* mov am,(abs32)    -> mov am,(abs16)
2185                      mov am,(d32,sp)   -> mov am,(d16,sp)
2186                      mov dm,(d32,sp)   -> mov dm,(d32,sp)
2187                      movbu dm,(d32,sp) -> movbu dm,(d32,sp)
2188                      movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
2189                   case 0x80:
2190                   case 0x90:
2191                   case 0x91:
2192                   case 0x92:
2193                   case 0x93:
2194                     /* Note that we've changed the relocation contents, etc.  */
2195                     elf_section_data (sec)->relocs = internal_relocs;
2196                     free_relocs = NULL;
2197
2198                     elf_section_data (sec)->this_hdr.contents = contents;
2199                     free_contents = NULL;
2200
2201                     symtab_hdr->contents = (bfd_byte *) extsyms;
2202                     free_extsyms = NULL;
2203
2204                     /* Fix the opcode.  */
2205                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2206                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2207
2208                     /* Fix the relocation's type.  */
2209                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2210                                                  R_MN10300_16);
2211
2212                     /* Delete two bytes of data.  */
2213                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2214                                                          irel->r_offset + 2, 2))
2215                       goto error_return;
2216
2217                     /* That will change things, so, we should relax again.
2218                        Note that this is not required, and it may be slow.  */
2219                     *again = true;
2220                     break;
2221                   }
2222               else if ((code & 0xf0) < 0xf0)
2223                 switch (code & 0xfc)
2224                   {
2225                   /* mov imm32,dn     -> mov imm16,dn
2226                      mov imm32,an     -> mov imm16,an
2227                      mov (abs32),dn   -> mov (abs16),dn
2228                      movbu (abs32),dn -> movbu (abs16),dn
2229                      movhu (abs32),dn -> movhu (abs16),dn  */
2230                   case 0xcc:
2231                   case 0xdc:
2232                   case 0xa4:
2233                   case 0xa8:
2234                   case 0xac:
2235                     /* Not safe if the high bit is on as relaxing may
2236                        move the value out of high mem and thus not fit
2237                        in a signed 16bit value.  */
2238                     if (code == 0xcc
2239                         && (value & 0x8000))
2240                       continue;
2241
2242                     /* Note that we've changed the relocation contents, etc.  */
2243                     elf_section_data (sec)->relocs = internal_relocs;
2244                     free_relocs = NULL;
2245
2246                     elf_section_data (sec)->this_hdr.contents = contents;
2247                     free_contents = NULL;
2248
2249                     symtab_hdr->contents = (bfd_byte *) extsyms;
2250                     free_extsyms = NULL;
2251
2252                     if ((code & 0xfc) == 0xcc)
2253                       code = 0x2c + (code & 0x03);
2254                     else if ((code & 0xfc) == 0xdc)
2255                       code = 0x24 + (code & 0x03);
2256                     else if ((code & 0xfc) == 0xa4)
2257                       code = 0x30 + (code & 0x03);
2258                     else if ((code & 0xfc) == 0xa8)
2259                       code = 0x34 + (code & 0x03);
2260                     else if ((code & 0xfc) == 0xac)
2261                       code = 0x38 + (code & 0x03);
2262                     else
2263                       abort ();
2264
2265                     /* Fix the opcode.  */
2266                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2267
2268                     /* Fix the relocation's type.  */
2269                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2270                                                  R_MN10300_16);
2271
2272                     /* The opcode got shorter too, so we have to fix the
2273                        addend and offset too!  */
2274                     irel->r_offset -= 1;
2275
2276                     /* Delete three bytes of data.  */
2277                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2278                                                          irel->r_offset + 1, 3))
2279                       goto error_return;
2280
2281                     /* That will change things, so, we should relax again.
2282                        Note that this is not required, and it may be slow.  */
2283                     *again = true;
2284                     break;
2285
2286                   /* mov (abs32),an    -> mov (abs16),an
2287                      mov (d32,sp),an   -> mov (d32,sp),an
2288                      mov (d32,sp),dn   -> mov (d32,sp),dn
2289                      movbu (d32,sp),dn -> movbu (d32,sp),dn
2290                      movhu (d32,sp),dn -> movhu (d32,sp),dn
2291                      add imm32,dn      -> add imm16,dn
2292                      cmp imm32,dn      -> cmp imm16,dn
2293                      add imm32,an      -> add imm16,an
2294                      cmp imm32,an      -> cmp imm16,an
2295                      and imm32,dn      -> and imm32,dn
2296                      or imm32,dn       -> or imm32,dn
2297                      xor imm32,dn      -> xor imm32,dn
2298                      btst imm32,dn     -> btst imm32,dn */
2299
2300                   case 0xa0:
2301                   case 0xb0:
2302                   case 0xb1:
2303                   case 0xb2:
2304                   case 0xb3:
2305                   case 0xc0:
2306                   case 0xc8:
2307
2308                   case 0xd0:
2309                   case 0xd8:
2310                   case 0xe0:
2311                   case 0xe1:
2312                   case 0xe2:
2313                   case 0xe3:
2314                     /* Note that we've changed the relocation contents, etc.  */
2315                     elf_section_data (sec)->relocs = internal_relocs;
2316                     free_relocs = NULL;
2317
2318                     elf_section_data (sec)->this_hdr.contents = contents;
2319                     free_contents = NULL;
2320
2321                     symtab_hdr->contents = (bfd_byte *) extsyms;
2322                     free_extsyms = NULL;
2323
2324                     /* Fix the opcode.  */
2325                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2326                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2327
2328                     /* Fix the relocation's type.  */
2329                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2330                                                  R_MN10300_16);
2331
2332                     /* Delete two bytes of data.  */
2333                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2334                                                          irel->r_offset + 2, 2))
2335                       goto error_return;
2336
2337                     /* That will change things, so, we should relax again.
2338                        Note that this is not required, and it may be slow.  */
2339                     *again = true;
2340                     break;
2341                   }
2342               else if (code == 0xfe)
2343                 {
2344                   /* add imm32,sp -> add imm16,sp  */
2345
2346                   /* Note that we've changed the relocation contents, etc.  */
2347                   elf_section_data (sec)->relocs = internal_relocs;
2348                   free_relocs = NULL;
2349
2350                   elf_section_data (sec)->this_hdr.contents = contents;
2351                   free_contents = NULL;
2352
2353                   symtab_hdr->contents = (bfd_byte *) extsyms;
2354                   free_extsyms = NULL;
2355
2356                   /* Fix the opcode.  */
2357                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2358                   bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
2359
2360                   /* Fix the relocation's type.  */
2361                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2362                                                  R_MN10300_16);
2363
2364                   /* Delete two bytes of data.  */
2365                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2366                                                        irel->r_offset + 2, 2))
2367                     goto error_return;
2368
2369                   /* That will change things, so, we should relax again.
2370                      Note that this is not required, and it may be slow.  */
2371                   *again = true;
2372                   break;
2373                 }
2374             }
2375         }
2376     }
2377
2378   if (free_relocs != NULL)
2379     {
2380       free (free_relocs);
2381       free_relocs = NULL;
2382     }
2383
2384   if (free_contents != NULL)
2385     {
2386       if (! link_info->keep_memory)
2387         free (free_contents);
2388       else
2389         {
2390           /* Cache the section contents for elf_link_input_bfd.  */
2391           elf_section_data (sec)->this_hdr.contents = contents;
2392         }
2393       free_contents = NULL;
2394     }
2395
2396   if (free_extsyms != NULL)
2397     {
2398       if (! link_info->keep_memory)
2399         free (free_extsyms);
2400       else
2401         {
2402           /* Cache the symbols for elf_link_input_bfd.  */
2403           symtab_hdr->contents = extsyms;
2404         }
2405       free_extsyms = NULL;
2406     }
2407
2408   return true;
2409
2410  error_return:
2411   if (free_relocs != NULL)
2412     free (free_relocs);
2413   if (free_contents != NULL)
2414     free (free_contents);
2415   if (free_extsyms != NULL)
2416     free (free_extsyms);
2417   return false;
2418 }
2419
2420 /* Compute the stack size and movm arguments for the function
2421    referred to by HASH at address ADDR in section with
2422    contents CONTENTS, store the information in the hash table.  */
2423 static void
2424 compute_function_info (abfd, hash, addr, contents)
2425      bfd *abfd;
2426      struct elf32_mn10300_link_hash_entry *hash;
2427      bfd_vma addr;
2428      unsigned char *contents;
2429 {
2430   unsigned char byte1, byte2;
2431   /* We only care about a very small subset of the possible prologue
2432      sequences here.  Basically we look for:
2433
2434      movm [d2,d3,a2,a3],sp (optional)
2435      add <size>,sp (optional, and only for sizes which fit in an unsigned
2436                     8 bit number)
2437
2438      If we find anything else, we quit.  */
2439
2440   /* Look for movm [regs],sp */
2441   byte1 = bfd_get_8 (abfd, contents + addr);
2442   byte2 = bfd_get_8 (abfd, contents + addr + 1);
2443
2444   if (byte1 == 0xcf)
2445     {
2446       hash->movm_args = byte2;
2447       addr += 2;
2448       byte1 = bfd_get_8 (abfd, contents + addr);
2449       byte2 = bfd_get_8 (abfd, contents + addr + 1);
2450     }
2451
2452   /* Now figure out how much stack space will be allocated by the movm
2453      instruction.  We need this kept separate from the funtion's normal
2454      stack space.  */
2455   if (hash->movm_args)
2456     {
2457       /* Space for d2.  */
2458       if (hash->movm_args & 0x80)
2459         hash->movm_stack_size += 4;
2460
2461       /* Space for d3.  */
2462       if (hash->movm_args & 0x40)
2463         hash->movm_stack_size += 4;
2464
2465       /* Space for a2.  */
2466       if (hash->movm_args & 0x20)
2467         hash->movm_stack_size += 4;
2468
2469       /* Space for a3.  */
2470       if (hash->movm_args & 0x10)
2471         hash->movm_stack_size += 4;
2472
2473       /* "other" space.  d0, d1, a0, a1, mdr, lir, lar, 4 byte pad.  */
2474       if (hash->movm_args & 0x08)
2475         hash->movm_stack_size += 8 * 4;
2476
2477       if (bfd_get_mach (abfd) == bfd_mach_am33)
2478         {
2479           /* "exother" space.  e0, e1, mdrq, mcrh, mcrl, mcvf */
2480           if (hash->movm_args & 0x1)
2481             hash->movm_stack_size += 6 * 4;
2482
2483           /* exreg1 space.  e4, e5, e6, e7 */
2484           if (hash->movm_args & 0x2)
2485             hash->movm_stack_size += 4 * 4;
2486
2487           /* exreg0 space.  e2, e3  */
2488           if (hash->movm_args & 0x4)
2489             hash->movm_stack_size += 2 * 4;
2490         }
2491     }
2492
2493   /* Now look for the two stack adjustment variants.  */
2494   if (byte1 == 0xf8 && byte2 == 0xfe)
2495     {
2496       int temp = bfd_get_8 (abfd, contents + addr + 2);
2497       temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2498
2499       hash->stack_size = -temp;
2500     }
2501   else if (byte1 == 0xfa && byte2 == 0xfe)
2502     {
2503       int temp = bfd_get_16 (abfd, contents + addr + 2);
2504       temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2505       temp = -temp;
2506
2507       if (temp < 255)
2508         hash->stack_size = temp;
2509     }
2510
2511   /* If the total stack to be allocated by the call instruction is more
2512      than 255 bytes, then we can't remove the stack adjustment by using
2513      "call" (we might still be able to remove the "movm" instruction.  */
2514   if (hash->stack_size + hash->movm_stack_size > 255)
2515     hash->stack_size = 0;
2516
2517   return;
2518 }
2519
2520 /* Delete some bytes from a section while relaxing.  */
2521
2522 static boolean
2523 mn10300_elf_relax_delete_bytes (abfd, sec, addr, count)
2524      bfd *abfd;
2525      asection *sec;
2526      bfd_vma addr;
2527      int count;
2528 {
2529   Elf_Internal_Shdr *symtab_hdr;
2530   Elf32_External_Sym *extsyms;
2531   int shndx, index;
2532   bfd_byte *contents;
2533   Elf_Internal_Rela *irel, *irelend;
2534   Elf_Internal_Rela *irelalign;
2535   bfd_vma toaddr;
2536   Elf32_External_Sym *esym, *esymend;
2537   struct elf32_mn10300_link_hash_entry *sym_hash;
2538
2539   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2540   extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2541
2542   shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2543
2544   contents = elf_section_data (sec)->this_hdr.contents;
2545
2546   /* The deletion must stop at the next ALIGN reloc for an aligment
2547      power larger than the number of bytes we are deleting.  */
2548
2549   irelalign = NULL;
2550   toaddr = sec->_cooked_size;
2551
2552   irel = elf_section_data (sec)->relocs;
2553   irelend = irel + sec->reloc_count;
2554
2555   /* Actually delete the bytes.  */
2556   memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2557   sec->_cooked_size -= count;
2558
2559   /* Adjust all the relocs.  */
2560   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2561     {
2562       /* Get the new reloc address.  */
2563       if ((irel->r_offset > addr
2564            && irel->r_offset < toaddr))
2565         irel->r_offset -= count;
2566     }
2567
2568   /* Adjust the local symbols defined in this section.  */
2569   esym = extsyms;
2570   esymend = esym + symtab_hdr->sh_info;
2571   for (; esym < esymend; esym++)
2572     {
2573       Elf_Internal_Sym isym;
2574
2575       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2576
2577       if (isym.st_shndx == shndx
2578           && isym.st_value > addr
2579           && isym.st_value < toaddr)
2580         {
2581           isym.st_value -= count;
2582           bfd_elf32_swap_symbol_out (abfd, &isym, esym);
2583         }
2584     }
2585
2586   /* Now adjust the global symbols defined in this section.  */
2587   esym = extsyms + symtab_hdr->sh_info;
2588   esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2589   for (index = 0; esym < esymend; esym++, index++)
2590     {
2591       Elf_Internal_Sym isym;
2592
2593       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2594       sym_hash = (struct elf32_mn10300_link_hash_entry *)
2595                    (elf_sym_hashes (abfd)[index]);
2596       if (isym.st_shndx == shndx
2597           && ((sym_hash)->root.root.type == bfd_link_hash_defined
2598               || (sym_hash)->root.root.type == bfd_link_hash_defweak)
2599           && (sym_hash)->root.root.u.def.section == sec
2600           && (sym_hash)->root.root.u.def.value > addr
2601           && (sym_hash)->root.root.u.def.value < toaddr)
2602         {
2603           (sym_hash)->root.root.u.def.value -= count;
2604         }
2605     }
2606
2607   return true;
2608 }
2609
2610 /* Return true if a symbol exists at the given address, else return
2611    false.  */
2612 static boolean
2613 mn10300_elf_symbol_address_p (abfd, sec, extsyms, addr)
2614      bfd *abfd;
2615      asection *sec;
2616      Elf32_External_Sym *extsyms;
2617      bfd_vma addr;
2618 {
2619   Elf_Internal_Shdr *symtab_hdr;
2620   int shndx;
2621   Elf32_External_Sym *esym, *esymend;
2622   struct elf32_mn10300_link_hash_entry **sym_hash, **sym_hash_end;
2623
2624   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2625   shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2626
2627   /* Examine all the symbols.  */
2628   esym = extsyms;
2629   esymend = esym + symtab_hdr->sh_info;
2630   for (; esym < esymend; esym++)
2631     {
2632       Elf_Internal_Sym isym;
2633
2634       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2635
2636       if (isym.st_shndx == shndx
2637           && isym.st_value == addr)
2638         return true;
2639     }
2640
2641   sym_hash = (struct elf32_mn10300_link_hash_entry **)(elf_sym_hashes (abfd));
2642   sym_hash_end = (sym_hash
2643                   + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2644                      - symtab_hdr->sh_info));
2645   for (; sym_hash < sym_hash_end; sym_hash++)
2646     {
2647       if (((*sym_hash)->root.root.type == bfd_link_hash_defined
2648            || (*sym_hash)->root.root.type == bfd_link_hash_defweak)
2649           && (*sym_hash)->root.root.u.def.section == sec
2650           && (*sym_hash)->root.root.u.def.value == addr)
2651         return true;
2652     }
2653   return false;
2654 }
2655
2656 /* This is a version of bfd_generic_get_relocated_section_contents
2657    which uses mn10300_elf_relocate_section.  */
2658
2659 static bfd_byte *
2660 mn10300_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
2661                                             data, relocateable, symbols)
2662      bfd *output_bfd;
2663      struct bfd_link_info *link_info;
2664      struct bfd_link_order *link_order;
2665      bfd_byte *data;
2666      boolean relocateable;
2667      asymbol **symbols;
2668 {
2669   Elf_Internal_Shdr *symtab_hdr;
2670   asection *input_section = link_order->u.indirect.section;
2671   bfd *input_bfd = input_section->owner;
2672   asection **sections = NULL;
2673   Elf_Internal_Rela *internal_relocs = NULL;
2674   Elf32_External_Sym *external_syms = NULL;
2675   Elf_Internal_Sym *internal_syms = NULL;
2676
2677   /* We only need to handle the case of relaxing, or of having a
2678      particular set of section contents, specially.  */
2679   if (relocateable
2680       || elf_section_data (input_section)->this_hdr.contents == NULL)
2681     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2682                                                        link_order, data,
2683                                                        relocateable,
2684                                                        symbols);
2685
2686   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2687
2688   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2689           input_section->_raw_size);
2690
2691   if ((input_section->flags & SEC_RELOC) != 0
2692       && input_section->reloc_count > 0)
2693     {
2694       Elf_Internal_Sym *isymp;
2695       asection **secpp;
2696       Elf32_External_Sym *esym, *esymend;
2697
2698       if (symtab_hdr->contents != NULL)
2699         external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
2700       else
2701         {
2702           external_syms = ((Elf32_External_Sym *)
2703                            bfd_malloc (symtab_hdr->sh_info
2704                                        * sizeof (Elf32_External_Sym)));
2705           if (external_syms == NULL && symtab_hdr->sh_info > 0)
2706             goto error_return;
2707           if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2708               || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
2709                             symtab_hdr->sh_info, input_bfd)
2710                   != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
2711             goto error_return;
2712         }
2713
2714       internal_relocs = (_bfd_elf32_link_read_relocs
2715                          (input_bfd, input_section, (PTR) NULL,
2716                           (Elf_Internal_Rela *) NULL, false));
2717       if (internal_relocs == NULL)
2718         goto error_return;
2719
2720       internal_syms = ((Elf_Internal_Sym *)
2721                        bfd_malloc (symtab_hdr->sh_info
2722                                    * sizeof (Elf_Internal_Sym)));
2723       if (internal_syms == NULL && symtab_hdr->sh_info > 0)
2724         goto error_return;
2725
2726       sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2727                                            * sizeof (asection *));
2728       if (sections == NULL && symtab_hdr->sh_info > 0)
2729         goto error_return;
2730
2731       isymp = internal_syms;
2732       secpp = sections;
2733       esym = external_syms;
2734       esymend = esym + symtab_hdr->sh_info;
2735       for (; esym < esymend; ++esym, ++isymp, ++secpp)
2736         {
2737           asection *isec;
2738
2739           bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
2740
2741           if (isymp->st_shndx == SHN_UNDEF)
2742             isec = bfd_und_section_ptr;
2743           else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
2744             isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2745           else if (isymp->st_shndx == SHN_ABS)
2746             isec = bfd_abs_section_ptr;
2747           else if (isymp->st_shndx == SHN_COMMON)
2748             isec = bfd_com_section_ptr;
2749           else
2750             {
2751               /* Who knows?  */
2752               isec = NULL;
2753             }
2754
2755           *secpp = isec;
2756         }
2757
2758       if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
2759                                      input_section, data, internal_relocs,
2760                                      internal_syms, sections))
2761         goto error_return;
2762
2763       if (sections != NULL)
2764         free (sections);
2765       sections = NULL;
2766       if (internal_syms != NULL)
2767         free (internal_syms);
2768       internal_syms = NULL;
2769       if (external_syms != NULL && symtab_hdr->contents == NULL)
2770         free (external_syms);
2771       external_syms = NULL;
2772       if (internal_relocs != elf_section_data (input_section)->relocs)
2773         free (internal_relocs);
2774       internal_relocs = NULL;
2775     }
2776
2777   return data;
2778
2779  error_return:
2780   if (internal_relocs != NULL
2781       && internal_relocs != elf_section_data (input_section)->relocs)
2782     free (internal_relocs);
2783   if (external_syms != NULL && symtab_hdr->contents == NULL)
2784     free (external_syms);
2785   if (internal_syms != NULL)
2786     free (internal_syms);
2787   if (sections != NULL)
2788     free (sections);
2789   return NULL;
2790 }
2791
2792 /* Assorted hash table functions.  */
2793
2794 /* Initialize an entry in the link hash table.  */
2795
2796 /* Create an entry in an MN10300 ELF linker hash table.  */
2797
2798 static struct bfd_hash_entry *
2799 elf32_mn10300_link_hash_newfunc (entry, table, string)
2800      struct bfd_hash_entry *entry;
2801      struct bfd_hash_table *table;
2802      const char *string;
2803 {
2804   struct elf32_mn10300_link_hash_entry *ret =
2805     (struct elf32_mn10300_link_hash_entry *) entry;
2806
2807   /* Allocate the structure if it has not already been allocated by a
2808      subclass.  */
2809   if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2810     ret = ((struct elf32_mn10300_link_hash_entry *)
2811            bfd_hash_allocate (table,
2812                               sizeof (struct elf32_mn10300_link_hash_entry)));
2813   if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2814     return (struct bfd_hash_entry *) ret;
2815
2816   /* Call the allocation method of the superclass.  */
2817   ret = ((struct elf32_mn10300_link_hash_entry *)
2818          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2819                                      table, string));
2820   if (ret != (struct elf32_mn10300_link_hash_entry *) NULL)
2821     {
2822       ret->direct_calls = 0;
2823       ret->stack_size = 0;
2824       ret->movm_stack_size = 0;
2825       ret->flags = 0;
2826       ret->movm_args = 0;
2827     }
2828
2829   return (struct bfd_hash_entry *) ret;
2830 }
2831
2832 /* Create an mn10300 ELF linker hash table.  */
2833
2834 static struct bfd_link_hash_table *
2835 elf32_mn10300_link_hash_table_create (abfd)
2836      bfd *abfd;
2837 {
2838   struct elf32_mn10300_link_hash_table *ret;
2839
2840   ret = ((struct elf32_mn10300_link_hash_table *)
2841          bfd_alloc (abfd, sizeof (struct elf32_mn10300_link_hash_table)));
2842   if (ret == (struct elf32_mn10300_link_hash_table *) NULL)
2843     return NULL;
2844
2845   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2846                                        elf32_mn10300_link_hash_newfunc))
2847     {
2848       bfd_release (abfd, ret);
2849       return NULL;
2850     }
2851
2852   ret->flags = 0;
2853   ret->static_hash_table
2854     = ((struct elf32_mn10300_link_hash_table *)
2855        bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
2856   if (ret->static_hash_table == NULL)
2857     {
2858       bfd_release (abfd, ret);
2859       return NULL;
2860     }
2861
2862   if (! _bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
2863                                        elf32_mn10300_link_hash_newfunc))
2864     {
2865       bfd_release (abfd, ret->static_hash_table);
2866       bfd_release (abfd, ret);
2867       return NULL;
2868     }
2869   return &ret->root.root;
2870 }
2871
2872 static int
2873 elf_mn10300_mach (flags)
2874      flagword flags;
2875 {
2876   switch (flags & EF_MN10300_MACH)
2877     {
2878       case E_MN10300_MACH_MN10300:
2879       default:
2880         return bfd_mach_mn10300;
2881
2882       case E_MN10300_MACH_AM33:
2883         return bfd_mach_am33;
2884     }
2885 }
2886
2887 /* The final processing done just before writing out a MN10300 ELF object
2888    file.  This gets the MN10300 architecture right based on the machine
2889    number.  */
2890
2891 /*ARGSUSED*/
2892 void
2893 _bfd_mn10300_elf_final_write_processing (abfd, linker)
2894      bfd *abfd;
2895      boolean linker ATTRIBUTE_UNUSED;
2896 {
2897   unsigned long val;
2898
2899   switch (bfd_get_mach (abfd))
2900     {
2901       default:
2902       case bfd_mach_mn10300:
2903         val = E_MN10300_MACH_MN10300;
2904         break;
2905
2906       case bfd_mach_am33:
2907         val = E_MN10300_MACH_AM33;
2908         break;
2909     }
2910
2911   elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
2912   elf_elfheader (abfd)->e_flags |= val;
2913 }
2914
2915 boolean
2916 _bfd_mn10300_elf_object_p (abfd)
2917      bfd *abfd;
2918 {
2919   bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
2920                              elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
2921   return true;
2922 }
2923
2924 /* Merge backend specific data from an object file to the output
2925    object file when linking.  */
2926
2927 boolean
2928 _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
2929      bfd *ibfd;
2930      bfd *obfd;
2931 {
2932   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2933       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2934     return true;
2935
2936   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2937       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
2938     {
2939       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2940                                bfd_get_mach (ibfd)))
2941         return false;
2942     }
2943
2944   return true;
2945 }
2946
2947
2948 #define TARGET_LITTLE_SYM       bfd_elf32_mn10300_vec
2949 #define TARGET_LITTLE_NAME      "elf32-mn10300"
2950 #define ELF_ARCH                bfd_arch_mn10300
2951 #define ELF_MACHINE_CODE        EM_CYGNUS_MN10300
2952 #define ELF_MAXPAGESIZE         0x1000
2953
2954 #define elf_info_to_howto               mn10300_info_to_howto
2955 #define elf_info_to_howto_rel           0
2956 #define elf_backend_can_gc_sections     1
2957 #define elf_backend_check_relocs        mn10300_elf_check_relocs
2958 #define elf_backend_gc_mark_hook        mn10300_elf_gc_mark_hook
2959 #define elf_backend_relocate_section    mn10300_elf_relocate_section
2960 #define bfd_elf32_bfd_relax_section     mn10300_elf_relax_section
2961 #define bfd_elf32_bfd_get_relocated_section_contents \
2962                                 mn10300_elf_get_relocated_section_contents
2963 #define bfd_elf32_bfd_link_hash_table_create \
2964                                 elf32_mn10300_link_hash_table_create
2965
2966 #define elf_symbol_leading_char '_'
2967
2968 /* So we can set bits in e_flags.  */
2969 #define elf_backend_final_write_processing \
2970                                         _bfd_mn10300_elf_final_write_processing
2971 #define elf_backend_object_p            _bfd_mn10300_elf_object_p
2972
2973 #define bfd_elf32_bfd_merge_private_bfd_data \
2974                                         _bfd_mn10300_elf_merge_private_bfd_data
2975
2976
2977 #include "elf32-target.h"