bfd/elf-m10300.c

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