bfd/elf-m10300.c

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