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