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,
  30            struct elf_link_hash_entry *, unsigned long, struct bfd_link_info *,
  31            asection *, int));
  32 static bfd_boolean mn10300_elf_relocate_section
  33   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  34            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  35 static bfd_boolean mn10300_elf_relax_section
  36   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
  37 static bfd_byte * mn10300_elf_get_relocated_section_contents
  38   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
  39            bfd_byte *, bfd_boolean, asymbol **));
  40 static unsigned long elf_mn10300_mach
  41   PARAMS ((flagword));
  42 void _bfd_mn10300_elf_final_write_processing
  43   PARAMS ((bfd *, bfd_boolean));
  44 bfd_boolean _bfd_mn10300_elf_object_p
  45   PARAMS ((bfd *));
  46 bfd_boolean _bfd_mn10300_elf_merge_private_bfd_data
  47   PARAMS ((bfd *,bfd *));
  48
  49 /* The mn10300 linker needs to keep track of the number of relocs that
  50    it decides to copy in check_relocs for each symbol.  This is so
  51    that it can discard PC relative relocs if it doesn't need them when
  52    linking with -Bsymbolic.  We store the information in a field
  53    extending the regular ELF linker hash table.  */
  54
  55 /* This structure keeps track of the number of PC relative relocs we
  56    have copied for a given symbol.  */
  57
  58 struct elf_mn10300_pcrel_relocs_copied
  59 {
  60   /* Next section.  */
  61   struct elf_mn10300_pcrel_relocs_copied * next;
  62   /* A section in dynobj.  */
  63   asection * section;
  64   /* Number of relocs copied in this section.  */
  65   bfd_size_type count;
  66 };
  67
  68 struct elf32_mn10300_link_hash_entry {
  69   /* The basic elf link hash table entry.  */
  70   struct elf_link_hash_entry root;
  71
  72   /* For function symbols, the number of times this function is
  73      called directly (ie by name).  */
  74   unsigned int direct_calls;
  75
  76   /* For function symbols, the size of this function's stack
  77      (if <= 255 bytes).  We stuff this into "call" instructions
  78      to this target when it's valid and profitable to do so.
  79
  80      This does not include stack allocated by movm!  */
  81   unsigned char stack_size;
  82
  83   /* For function symbols, arguments (if any) for movm instruction
  84      in the prologue.  We stuff this value into "call" instructions
  85      to the target when it's valid and profitable to do so.  */
  86   unsigned char movm_args;
  87
  88   /* For funtion symbols, the amount of stack space that would be allocated
  89      by the movm instruction.  This is redundant with movm_args, but we
  90      add it to the hash table to avoid computing it over and over.  */
  91   unsigned char movm_stack_size;
  92
  93   /* Number of PC relative relocs copied for this symbol.  */
  94   struct elf_mn10300_pcrel_relocs_copied * pcrel_relocs_copied;
  95
  96 /* When set, convert all "call" instructions to this target into "calls"
  97    instructions.  */
  98 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
  99
 100 /* Used to mark functions which have had redundant parts of their
 101    prologue deleted.  */
 102 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
 103   unsigned char flags;
 104 };
 105
 106 /* We derive a hash table from the main elf linker hash table so
 107    we can store state variables and a secondary hash table without
 108    resorting to global variables.  */
 109 struct elf32_mn10300_link_hash_table {
 110   /* The main hash table.  */
 111   struct elf_link_hash_table root;
 112
 113   /* A hash table for static functions.  We could derive a new hash table
 114      instead of using the full elf32_mn10300_link_hash_table if we wanted
 115      to save some memory.  */
 116   struct elf32_mn10300_link_hash_table *static_hash_table;
 117
 118   /* Random linker state flags.  */
 119 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
 120   char flags;
 121 };
 122
 123 /* For MN10300 linker hash table.  */
 124
 125 /* Get the MN10300 ELF linker hash table from a link_info structure.  */
 126
 127 #define elf32_mn10300_hash_table(p) \
 128   ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
 129
 130 #define elf32_mn10300_link_hash_traverse(table, func, info)             \
 131   (elf_link_hash_traverse                                               \
 132    (&(table)->root,                                                     \
 133     (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
 134     (info)))
 135
 136 static struct bfd_hash_entry *elf32_mn10300_link_hash_newfunc
 137   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 138 static struct bfd_link_hash_table *elf32_mn10300_link_hash_table_create
 139   PARAMS ((bfd *));
 140 static void elf32_mn10300_link_hash_table_free
 141   PARAMS ((struct bfd_link_hash_table *));
 142
 143 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
 144   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
 145 static void mn10300_info_to_howto
 146   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
 147 static bfd_boolean mn10300_elf_check_relocs
 148   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 149            const Elf_Internal_Rela *));
 150 static asection *mn10300_elf_gc_mark_hook
 151   PARAMS ((asection *, struct bfd_link_info *info, Elf_Internal_Rela *,
 152            struct elf_link_hash_entry *, Elf_Internal_Sym *));
 153 static bfd_boolean mn10300_elf_relax_delete_bytes
 154   PARAMS ((bfd *, asection *, bfd_vma, int));
 155 static bfd_boolean mn10300_elf_symbol_address_p
 156   PARAMS ((bfd *, asection *, Elf_Internal_Sym *, bfd_vma));
 157 static bfd_boolean elf32_mn10300_finish_hash_table_entry
 158   PARAMS ((struct bfd_hash_entry *, PTR));
 159 static void compute_function_info
 160   PARAMS ((bfd *, struct elf32_mn10300_link_hash_entry *,
 161            bfd_vma, unsigned char *));
 162
 163 static bfd_boolean _bfd_mn10300_elf_create_got_section
 164   PARAMS ((bfd *, struct bfd_link_info *));
 165 static bfd_boolean _bfd_mn10300_elf_create_dynamic_sections
 166   PARAMS ((bfd *, struct bfd_link_info *));
 167 static bfd_boolean _bfd_mn10300_elf_adjust_dynamic_symbol
 168   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
 169 static bfd_boolean _bfd_mn10300_elf_discard_copies
 170   PARAMS ((struct elf32_mn10300_link_hash_entry *,
 171            struct bfd_link_info *));
 172 static bfd_boolean _bfd_mn10300_elf_size_dynamic_sections
 173   PARAMS ((bfd *, struct bfd_link_info *));
 174 static bfd_boolean _bfd_mn10300_elf_finish_dynamic_symbol
 175   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
 176            Elf_Internal_Sym *));
 177 static bfd_boolean _bfd_mn10300_elf_finish_dynamic_sections
 178   PARAMS ((bfd *, struct bfd_link_info *));
 179
 180 static reloc_howto_type elf_mn10300_howto_table[] = {
 181   /* Dummy relocation.  Does nothing.  */
 182   HOWTO (R_MN10300_NONE,
 183          0,
 184          2,
 185          16,
 186          FALSE,
 187          0,
 188          complain_overflow_bitfield,
 189          bfd_elf_generic_reloc,
 190          "R_MN10300_NONE",
 191          FALSE,
 192          0,
 193          0,
 194          FALSE),
 195   /* Standard 32 bit reloc.  */
 196   HOWTO (R_MN10300_32,
 197          0,
 198          2,
 199          32,
 200          FALSE,
 201          0,
 202          complain_overflow_bitfield,
 203          bfd_elf_generic_reloc,
 204          "R_MN10300_32",
 205          FALSE,
 206          0xffffffff,
 207          0xffffffff,
 208          FALSE),
 209   /* Standard 16 bit reloc.  */
 210   HOWTO (R_MN10300_16,
 211          0,
 212          1,
 213          16,
 214          FALSE,
 215          0,
 216          complain_overflow_bitfield,
 217          bfd_elf_generic_reloc,
 218          "R_MN10300_16",
 219          FALSE,
 220          0xffff,
 221          0xffff,
 222          FALSE),
 223   /* Standard 8 bit reloc.  */
 224   HOWTO (R_MN10300_8,
 225          0,
 226          0,
 227          8,
 228          FALSE,
 229          0,
 230          complain_overflow_bitfield,
 231          bfd_elf_generic_reloc,
 232          "R_MN10300_8",
 233          FALSE,
 234          0xff,
 235          0xff,
 236          FALSE),
 237   /* Standard 32bit pc-relative reloc.  */
 238   HOWTO (R_MN10300_PCREL32,
 239          0,
 240          2,
 241          32,
 242          TRUE,
 243          0,
 244          complain_overflow_bitfield,
 245          bfd_elf_generic_reloc,
 246          "R_MN10300_PCREL32",
 247          FALSE,
 248          0xffffffff,
 249          0xffffffff,
 250          TRUE),
 251   /* Standard 16bit pc-relative reloc.  */
 252   HOWTO (R_MN10300_PCREL16,
 253          0,
 254          1,
 255          16,
 256          TRUE,
 257          0,
 258          complain_overflow_bitfield,
 259          bfd_elf_generic_reloc,
 260          "R_MN10300_PCREL16",
 261          FALSE,
 262          0xffff,
 263          0xffff,
 264          TRUE),
 265   /* Standard 8 pc-relative reloc.  */
 266   HOWTO (R_MN10300_PCREL8,
 267          0,
 268          0,
 269          8,
 270          TRUE,
 271          0,
 272          complain_overflow_bitfield,
 273          bfd_elf_generic_reloc,
 274          "R_MN10300_PCREL8",
 275          FALSE,
 276          0xff,
 277          0xff,
 278          TRUE),
 279
 280   /* GNU extension to record C++ vtable hierarchy */
 281   HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
 282          0,                     /* rightshift */
 283          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 284          0,                     /* bitsize */
 285          FALSE,                 /* pc_relative */
 286          0,                     /* bitpos */
 287          complain_overflow_dont, /* complain_on_overflow */
 288          NULL,                  /* special_function */
 289          "R_MN10300_GNU_VTINHERIT", /* name */
 290          FALSE,                 /* partial_inplace */
 291          0,                     /* src_mask */
 292          0,                     /* dst_mask */
 293          FALSE),                /* pcrel_offset */
 294
 295   /* GNU extension to record C++ vtable member usage */
 296   HOWTO (R_MN10300_GNU_VTENTRY, /* type */
 297          0,                     /* rightshift */
 298          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 299          0,                     /* bitsize */
 300          FALSE,                 /* pc_relative */
 301          0,                     /* bitpos */
 302          complain_overflow_dont, /* complain_on_overflow */
 303          NULL,                  /* special_function */
 304          "R_MN10300_GNU_VTENTRY", /* name */
 305          FALSE,                 /* partial_inplace */
 306          0,                     /* src_mask */
 307          0,                     /* dst_mask */
 308          FALSE),                /* pcrel_offset */
 309
 310   /* Standard 24 bit reloc.  */
 311   HOWTO (R_MN10300_24,
 312          0,
 313          2,
 314          24,
 315          FALSE,
 316          0,
 317          complain_overflow_bitfield,
 318          bfd_elf_generic_reloc,
 319          "R_MN10300_24",
 320          FALSE,
 321          0xffffff,
 322          0xffffff,
 323          FALSE),
 324   HOWTO (R_MN10300_GOTPC32,     /* type */
 325          0,                     /* rightshift */
 326          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 327          32,                    /* bitsize */
 328          TRUE,                  /* pc_relative */
 329          0,                     /* bitpos */
 330          complain_overflow_bitfield, /* complain_on_overflow */
 331          bfd_elf_generic_reloc, /* */
 332          "R_MN10300_GOTPC32",   /* name */
 333          FALSE,                 /* partial_inplace */
 334          0xffffffff,            /* src_mask */
 335          0xffffffff,            /* dst_mask */
 336          TRUE),                 /* pcrel_offset */
 337
 338   HOWTO (R_MN10300_GOTPC16,     /* type */
 339          0,                     /* rightshift */
 340          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          TRUE,                  /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_bitfield, /* complain_on_overflow */
 345          bfd_elf_generic_reloc, /* */
 346          "R_MN10300_GOTPC16",   /* name */
 347          FALSE,                 /* partial_inplace */
 348          0xffff,                /* src_mask */
 349          0xffff,                /* dst_mask */
 350          TRUE),                 /* pcrel_offset */
 351
 352   HOWTO (R_MN10300_GOTOFF32,    /* type */
 353          0,                     /* rightshift */
 354          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 355          32,                    /* bitsize */
 356          FALSE,                 /* pc_relative */
 357          0,                     /* bitpos */
 358          complain_overflow_bitfield, /* complain_on_overflow */
 359          bfd_elf_generic_reloc, /* */
 360          "R_MN10300_GOTOFF32",  /* name */
 361          FALSE,                 /* partial_inplace */
 362          0xffffffff,            /* src_mask */
 363          0xffffffff,            /* dst_mask */
 364          FALSE),                /* pcrel_offset */
 365
 366   HOWTO (R_MN10300_GOTOFF24,    /* type */
 367          0,                     /* rightshift */
 368          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          24,                    /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_bitfield, /* complain_on_overflow */
 373          bfd_elf_generic_reloc, /* */
 374          "R_MN10300_GOTOFF24",  /* name */
 375          FALSE,                 /* partial_inplace */
 376          0xffffff,              /* src_mask */
 377          0xffffff,              /* dst_mask */
 378          FALSE),                /* pcrel_offset */
 379
 380   HOWTO (R_MN10300_GOTOFF16,    /* type */
 381          0,                     /* rightshift */
 382          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 383          16,                    /* bitsize */
 384          FALSE,                 /* pc_relative */
 385          0,                     /* bitpos */
 386          complain_overflow_bitfield, /* complain_on_overflow */
 387          bfd_elf_generic_reloc, /* */
 388          "R_MN10300_GOTOFF16",  /* name */
 389          FALSE,                 /* partial_inplace */
 390          0xffff,                /* src_mask */
 391          0xffff,                /* dst_mask */
 392          FALSE),                /* pcrel_offset */
 393
 394   HOWTO (R_MN10300_PLT32,       /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          32,                    /* bitsize */
 398          TRUE,                  /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_bitfield, /* complain_on_overflow */
 401          bfd_elf_generic_reloc, /* */
 402          "R_MN10300_PLT32",     /* name */
 403          FALSE,                 /* partial_inplace */
 404          0xffffffff,            /* src_mask */
 405          0xffffffff,            /* dst_mask */
 406          TRUE),                 /* pcrel_offset */
 407
 408   HOWTO (R_MN10300_PLT16,       /* type */
 409          0,                     /* rightshift */
 410          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          16,                    /* bitsize */
 412          TRUE,                  /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_bitfield, /* complain_on_overflow */
 415          bfd_elf_generic_reloc, /* */
 416          "R_MN10300_PLT16",     /* name */
 417          FALSE,                 /* partial_inplace */
 418          0xffff,                /* src_mask */
 419          0xffff,                /* dst_mask */
 420          TRUE),                 /* pcrel_offset */
 421
 422   HOWTO (R_MN10300_GOT32,       /* type */
 423          0,                     /* rightshift */
 424          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          32,                    /* bitsize */
 426          FALSE,                 /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_bitfield, /* complain_on_overflow */
 429          bfd_elf_generic_reloc, /* */
 430          "R_MN10300_GOT32",     /* name */
 431          FALSE,                 /* partial_inplace */
 432          0xffffffff,            /* src_mask */
 433          0xffffffff,            /* dst_mask */
 434          FALSE),                /* pcrel_offset */
 435
 436   HOWTO (R_MN10300_GOT24,       /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          24,                    /* bitsize */
 440          FALSE,                 /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_bitfield, /* complain_on_overflow */
 443          bfd_elf_generic_reloc, /* */
 444          "R_MN10300_GOT24",     /* name */
 445          FALSE,                 /* partial_inplace */
 446          0xffffffff,            /* src_mask */
 447          0xffffffff,            /* dst_mask */
 448          FALSE),                /* pcrel_offset */
 449
 450   HOWTO (R_MN10300_GOT16,       /* type */
 451          0,                     /* rightshift */
 452          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 453          16,                    /* bitsize */
 454          FALSE,                 /* pc_relative */
 455          0,                     /* bitpos */
 456          complain_overflow_bitfield, /* complain_on_overflow */
 457          bfd_elf_generic_reloc, /* */
 458          "R_MN10300_GOT16",     /* name */
 459          FALSE,                 /* partial_inplace */
 460          0xffffffff,            /* src_mask */
 461          0xffffffff,            /* dst_mask */
 462          FALSE),                /* pcrel_offset */
 463
 464   HOWTO (R_MN10300_COPY,        /* type */
 465          0,                     /* rightshift */
 466          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 467          32,                    /* bitsize */
 468          FALSE,                 /* pc_relative */
 469          0,                     /* bitpos */
 470          complain_overflow_bitfield, /* complain_on_overflow */
 471          bfd_elf_generic_reloc, /* */
 472          "R_MN10300_COPY",              /* name */
 473          FALSE,                 /* partial_inplace */
 474          0xffffffff,            /* src_mask */
 475          0xffffffff,            /* dst_mask */
 476          FALSE),                /* pcrel_offset */
 477
 478   HOWTO (R_MN10300_GLOB_DAT,    /* type */
 479          0,                     /* rightshift */
 480          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 481          32,                    /* bitsize */
 482          FALSE,                 /* pc_relative */
 483          0,                     /* bitpos */
 484          complain_overflow_bitfield, /* complain_on_overflow */
 485          bfd_elf_generic_reloc, /* */
 486          "R_MN10300_GLOB_DAT",  /* name */
 487          FALSE,                 /* partial_inplace */
 488          0xffffffff,            /* src_mask */
 489          0xffffffff,            /* dst_mask */
 490          FALSE),                /* pcrel_offset */
 491
 492   HOWTO (R_MN10300_JMP_SLOT,    /* type */
 493          0,                     /* rightshift */
 494          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 495          32,                    /* bitsize */
 496          FALSE,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_bitfield, /* complain_on_overflow */
 499          bfd_elf_generic_reloc, /* */
 500          "R_MN10300_JMP_SLOT",  /* name */
 501          FALSE,                 /* partial_inplace */
 502          0xffffffff,            /* src_mask */
 503          0xffffffff,            /* dst_mask */
 504          FALSE),                /* pcrel_offset */
 505
 506   HOWTO (R_MN10300_RELATIVE,    /* type */
 507          0,                     /* rightshift */
 508          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 509          32,                    /* bitsize */
 510          FALSE,                 /* pc_relative */
 511          0,                     /* bitpos */
 512          complain_overflow_bitfield, /* complain_on_overflow */
 513          bfd_elf_generic_reloc, /* */
 514          "R_MN10300_RELATIVE",  /* name */
 515          FALSE,                 /* partial_inplace */
 516          0xffffffff,            /* src_mask */
 517          0xffffffff,            /* dst_mask */
 518          FALSE),                /* pcrel_offset */
 519
 520 };
 521
 522 struct mn10300_reloc_map {
 523   bfd_reloc_code_real_type bfd_reloc_val;
 524   unsigned char elf_reloc_val;
 525 };
 526
 527 static const struct mn10300_reloc_map mn10300_reloc_map[] = {
 528   { BFD_RELOC_NONE, R_MN10300_NONE, },
 529   { BFD_RELOC_32, R_MN10300_32, },
 530   { BFD_RELOC_16, R_MN10300_16, },
 531   { BFD_RELOC_8, R_MN10300_8, },
 532   { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
 533   { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
 534   { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
 535   { BFD_RELOC_24, R_MN10300_24, },
 536   { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
 537   { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
 538   { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
 539   { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
 540   { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
 541   { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
 542   { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
 543   { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
 544   { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
 545   { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
 546   { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
 547   { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
 548   { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
 549   { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
 550   { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
 551   { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
 552 };
 553
 554 /* Create the GOT section.  */
 555
 556 static bfd_boolean
 557 _bfd_mn10300_elf_create_got_section (abfd, info)
 558      bfd * abfd;
 559      struct bfd_link_info * info;
 560 {
 561   flagword   flags;
 562   flagword   pltflags;
 563   asection * s;
 564   struct elf_link_hash_entry * h;
 565   struct elf_backend_data *    bed = get_elf_backend_data (abfd);
 566   int ptralign;
 567
 568   /* This function may be called more than once.  */
 569   if (bfd_get_section_by_name (abfd, ".got") != NULL)
 570     return TRUE;
 571
 572   switch (bed->s->arch_size)
 573     {
 574     case 32:
 575       ptralign = 2;
 576       break;
 577
 578     case 64:
 579       ptralign = 3;
 580       break;
 581
 582     default:
 583       bfd_set_error (bfd_error_bad_value);
 584       return FALSE;
 585     }
 586
 587   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 588            | SEC_LINKER_CREATED);
 589
 590   pltflags = flags;
 591   pltflags |= SEC_CODE;
 592   if (bed->plt_not_loaded)
 593     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
 594   if (bed->plt_readonly)
 595     pltflags |= SEC_READONLY;
 596
 597   s = bfd_make_section (abfd, ".plt");
 598   if (s == NULL
 599       || ! bfd_set_section_flags (abfd, s, pltflags)
 600       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
 601     return FALSE;
 602
 603   if (bed->want_plt_sym)
 604     {
 605       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
 606          .plt section.  */
 607       struct elf_link_hash_entry *h = NULL;
 608       if (! (_bfd_generic_link_add_one_symbol
 609              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
 610               (bfd_vma) 0, (const char *) NULL, FALSE,
 611               get_elf_backend_data (abfd)->collect,
 612               (struct bfd_link_hash_entry **) &h)))
 613         return FALSE;
 614       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 615       h->type = STT_OBJECT;
 616
 617       if (info->shared
 618           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 619         return FALSE;
 620     }
 621
 622   s = bfd_make_section (abfd, ".got");
 623   if (s == NULL
 624       || ! bfd_set_section_flags (abfd, s, flags)
 625       || ! bfd_set_section_alignment (abfd, s, ptralign))
 626     return FALSE;
 627
 628   if (bed->want_got_plt)
 629     {
 630       s = bfd_make_section (abfd, ".got.plt");
 631       if (s == NULL
 632           || ! bfd_set_section_flags (abfd, s, flags)
 633           || ! bfd_set_section_alignment (abfd, s, ptralign))
 634         return FALSE;
 635     }
 636
 637   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
 638      (or .got.plt) section.  We don't do this in the linker script
 639      because we don't want to define the symbol if we are not creating
 640      a global offset table.  */
 641   h = NULL;
 642   if (!(_bfd_generic_link_add_one_symbol
 643         (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
 644          bed->got_symbol_offset, (const char *) NULL, FALSE,
 645          bed->collect, (struct bfd_link_hash_entry **) &h)))
 646     return FALSE;
 647   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
 648   h->type = STT_OBJECT;
 649
 650   if (info->shared
 651       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
 652     return FALSE;
 653
 654   elf_hash_table (info)->hgot = h;
 655
 656   /* The first bit of the global offset table is the header.  */
 657   s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
 658
 659   return TRUE;
 660 }
 661
 662 static reloc_howto_type *
 663 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
 664      bfd *abfd ATTRIBUTE_UNUSED;
 665      bfd_reloc_code_real_type code;
 666 {
 667   unsigned int i;
 668
 669   for (i = 0;
 670        i < sizeof (mn10300_reloc_map) / sizeof (struct mn10300_reloc_map);
 671        i++)
 672     {
 673       if (mn10300_reloc_map[i].bfd_reloc_val == code)
 674         return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
 675     }
 676
 677   return NULL;
 678 }
 679
 680 /* Set the howto pointer for an MN10300 ELF reloc.  */
 681
 682 static void
 683 mn10300_info_to_howto (abfd, cache_ptr, dst)
 684      bfd *abfd ATTRIBUTE_UNUSED;
 685      arelent *cache_ptr;
 686      Elf_Internal_Rela *dst;
 687 {
 688   unsigned int r_type;
 689
 690   r_type = ELF32_R_TYPE (dst->r_info);
 691   BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
 692   cache_ptr->howto = &elf_mn10300_howto_table[r_type];
 693 }
 694
 695 /* Look through the relocs for a section during the first phase.
 696    Since we don't do .gots or .plts, we just need to consider the
 697    virtual table relocs for gc.  */
 698
 699 static bfd_boolean
 700 mn10300_elf_check_relocs (abfd, info, sec, relocs)
 701      bfd *abfd;
 702      struct bfd_link_info *info;
 703      asection *sec;
 704      const Elf_Internal_Rela *relocs;
 705 {
 706   Elf_Internal_Shdr *symtab_hdr;
 707   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 708   const Elf_Internal_Rela *rel;
 709   const Elf_Internal_Rela *rel_end;
 710   bfd *      dynobj;
 711   bfd_vma *  local_got_offsets;
 712   asection * sgot;
 713   asection * srelgot;
 714   asection * sreloc;
 715
 716   sgot    = NULL;
 717   srelgot = NULL;
 718   sreloc  = NULL;
 719
 720   if (info->relocatable)
 721     return TRUE;
 722
 723   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 724   sym_hashes = elf_sym_hashes (abfd);
 725   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
 726   if (!elf_bad_symtab (abfd))
 727     sym_hashes_end -= symtab_hdr->sh_info;
 728
 729   dynobj = elf_hash_table (info)->dynobj;
 730   local_got_offsets = elf_local_got_offsets (abfd);
 731   rel_end = relocs + sec->reloc_count;
 732   for (rel = relocs; rel < rel_end; rel++)
 733     {
 734       struct elf_link_hash_entry *h;
 735       unsigned long r_symndx;
 736
 737       r_symndx = ELF32_R_SYM (rel->r_info);
 738       if (r_symndx < symtab_hdr->sh_info)
 739         h = NULL;
 740       else
 741         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 742
 743       /* Some relocs require a global offset table.  */
 744       if (dynobj == NULL)
 745         {
 746           switch (ELF32_R_TYPE (rel->r_info))
 747             {
 748             case R_MN10300_GOT32:
 749             case R_MN10300_GOT24:
 750             case R_MN10300_GOT16:
 751             case R_MN10300_GOTOFF32:
 752             case R_MN10300_GOTOFF24:
 753             case R_MN10300_GOTOFF16:
 754             case R_MN10300_GOTPC32:
 755             case R_MN10300_GOTPC16:
 756               elf_hash_table (info)->dynobj = dynobj = abfd;
 757               if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
 758                 return FALSE;
 759               break;
 760
 761             default:
 762               break;
 763             }
 764         }
 765
 766       switch (ELF32_R_TYPE (rel->r_info))
 767         {
 768         /* This relocation describes the C++ object vtable hierarchy.
 769            Reconstruct it for later use during GC.  */
 770         case R_MN10300_GNU_VTINHERIT:
 771           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 772             return FALSE;
 773           break;
 774
 775         /* This relocation describes which C++ vtable entries are actually
 776            used.  Record for later use during GC.  */
 777         case R_MN10300_GNU_VTENTRY:
 778           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 779             return FALSE;
 780           break;
 781         case R_MN10300_GOT32:
 782         case R_MN10300_GOT24:
 783         case R_MN10300_GOT16:
 784           /* This symbol requires a global offset table entry.  */
 785
 786           if (sgot == NULL)
 787             {
 788               sgot = bfd_get_section_by_name (dynobj, ".got");
 789               BFD_ASSERT (sgot != NULL);
 790             }
 791
 792           if (srelgot == NULL
 793               && (h != NULL || info->shared))
 794             {
 795               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 796               if (srelgot == NULL)
 797                 {
 798                   srelgot = bfd_make_section (dynobj, ".rela.got");
 799                   if (srelgot == NULL
 800                       || ! bfd_set_section_flags (dynobj, srelgot,
 801                                                   (SEC_ALLOC
 802                                                    | SEC_LOAD
 803                                                    | SEC_HAS_CONTENTS
 804                                                    | SEC_IN_MEMORY
 805                                                    | SEC_LINKER_CREATED
 806                                                    | SEC_READONLY))
 807                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
 808                     return FALSE;
 809                 }
 810             }
 811
 812           if (h != NULL)
 813             {
 814               if (h->got.offset != (bfd_vma) -1)
 815                 /* We have already allocated space in the .got.  */
 816                 break;
 817
 818               h->got.offset = sgot->_raw_size;
 819
 820               /* Make sure this symbol is output as a dynamic symbol.  */
 821               if (h->dynindx == -1)
 822                 {
 823                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 824                     return FALSE;
 825                 }
 826
 827               srelgot->_raw_size += sizeof (Elf32_External_Rela);
 828             }
 829           else
 830             {
 831               /* This is a global offset table entry for a local
 832                  symbol.  */
 833               if (local_got_offsets == NULL)
 834                 {
 835                   size_t       size;
 836                   unsigned int i;
 837
 838                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
 839                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
 840
 841                   if (local_got_offsets == NULL)
 842                     return FALSE;
 843                   elf_local_got_offsets (abfd) = local_got_offsets;
 844
 845                   for (i = 0; i < symtab_hdr->sh_info; i++)
 846                     local_got_offsets[i] = (bfd_vma) -1;
 847                 }
 848
 849               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
 850                 /* We have already allocated space in the .got.  */
 851                 break;
 852
 853               local_got_offsets[r_symndx] = sgot->_raw_size;
 854
 855               if (info->shared)
 856                 /* If we are generating a shared object, we need to
 857                    output a R_MN10300_RELATIVE reloc so that the dynamic
 858                    linker can adjust this GOT entry.  */
 859                 srelgot->_raw_size += sizeof (Elf32_External_Rela);
 860             }
 861
 862           sgot->_raw_size += 4;
 863
 864           break;
 865
 866         case R_MN10300_PLT32:
 867         case R_MN10300_PLT16:
 868           /* This symbol requires a procedure linkage table entry.  We
 869              actually build the entry in adjust_dynamic_symbol,
 870              because this might be a case of linking PIC code which is
 871              never referenced by a dynamic object, in which case we
 872              don't need to generate a procedure linkage table entry
 873              after all.  */
 874
 875           /* If this is a local symbol, we resolve it directly without
 876              creating a procedure linkage table entry.  */
 877           if (h == NULL)
 878             continue;
 879
 880           if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
 881               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
 882             break;
 883
 884           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 885
 886           break;
 887
 888         case R_MN10300_32:
 889         case R_MN10300_24:
 890         case R_MN10300_16:
 891         case R_MN10300_8:
 892         case R_MN10300_PCREL32:
 893         case R_MN10300_PCREL16:
 894         case R_MN10300_PCREL8:
 895           if (h != NULL)
 896             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 897
 898           /* If we are creating a shared library, and this is a reloc
 899              against a global symbol, or a non PC relative reloc
 900              against a local symbol, then we need to copy the reloc
 901              into the shared library.  However, if we are linking with
 902              -Bsymbolic, we do not need to copy a reloc against a
 903              global symbol which is defined in an object we are
 904              including in the link (i.e., DEF_REGULAR is set).  At
 905              this point we have not seen all the input files, so it is
 906              possible that DEF_REGULAR is not set now but will be set
 907              later (it is never cleared).  We account for that
 908              possibility below by storing information in the
 909              pcrel_relocs_copied field of the hash table entry.  */
 910           if (info->shared
 911               && (sec->flags & SEC_ALLOC) != 0
 912               && (! (elf_mn10300_howto_table[ELF32_R_TYPE (rel->r_info)]
 913                      .pc_relative)
 914                   || (h != NULL
 915                       && (! info->symbolic
 916                           || h->root.type == bfd_link_hash_defweak
 917                           || (h->elf_link_hash_flags
 918                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
 919             {
 920               /* When creating a shared object, we must copy these
 921                  reloc types into the output file.  We create a reloc
 922                  section in dynobj and make room for this reloc.  */
 923               if (sreloc == NULL)
 924                 {
 925                   const char * name;
 926
 927                   name = (bfd_elf_string_from_elf_section
 928                           (abfd,
 929                            elf_elfheader (abfd)->e_shstrndx,
 930                            elf_section_data (sec)->rel_hdr.sh_name));
 931                   if (name == NULL)
 932                     return FALSE;
 933
 934                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
 935                               && strcmp (bfd_get_section_name (abfd, sec),
 936                                          name + 5) == 0);
 937
 938                   sreloc = bfd_get_section_by_name (dynobj, name);
 939                   if (sreloc == NULL)
 940                     {
 941                       flagword flags;
 942
 943                       sreloc = bfd_make_section (dynobj, name);
 944                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
 945                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 946                       if ((sec->flags & SEC_ALLOC) != 0)
 947                         flags |= SEC_ALLOC | SEC_LOAD;
 948                       if (sreloc == NULL
 949                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
 950                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 951                         return FALSE;
 952                     }
 953                 }
 954
 955               sreloc->_raw_size += sizeof (Elf32_External_Rela);
 956
 957               /* If we are linking with -Bsymbolic, and this is a
 958                  global symbol, we count the number of PC relative
 959                  relocations we have entered for this symbol, so that
 960                  we can discard them again if the symbol is later
 961                  defined by a regular object.  Note that this function
 962                  is only called if we are using an elf_sh linker
 963                  hash table, which means that h is really a pointer to
 964                  an elf32_mn10300_link_hash_entry.  */
 965               if (h != NULL
 966                   && (elf_mn10300_howto_table[ELF32_R_TYPE (rel->r_info)]
 967                       .pc_relative))
 968                 {
 969                   struct elf32_mn10300_link_hash_entry *eh;
 970                   struct elf_mn10300_pcrel_relocs_copied *p;
 971
 972                   eh = (struct elf32_mn10300_link_hash_entry *) h;
 973
 974                   for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
 975                     if (p->section == sreloc)
 976                       break;
 977
 978                   if (p == NULL)
 979                     {
 980                       p = ((struct elf_mn10300_pcrel_relocs_copied *)
 981                            bfd_alloc (dynobj, sizeof *p));
 982                       if (p == NULL)
 983                         return FALSE;
 984
 985                       p->next = eh->pcrel_relocs_copied;
 986                       eh->pcrel_relocs_copied = p;
 987                       p->section = sreloc;
 988                       p->count = 0;
 989                     }
 990
 991                   ++p->count;
 992                 }
 993             }
 994
 995           break;
 996         }
 997     }
 998
 999   return TRUE;
1000 }
1001
1002 /* Return the section that should be marked against GC for a given
1003    relocation.  */
1004
1005 static asection *
1006 mn10300_elf_gc_mark_hook (sec, info, rel, h, sym)
1007      asection *sec;
1008      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1009      Elf_Internal_Rela *rel;
1010      struct elf_link_hash_entry *h;
1011      Elf_Internal_Sym *sym;
1012 {
1013   if (h != NULL)
1014     {
1015       switch (ELF32_R_TYPE (rel->r_info))
1016         {
1017         case R_MN10300_GNU_VTINHERIT:
1018         case R_MN10300_GNU_VTENTRY:
1019           break;
1020
1021         default:
1022           switch (h->root.type)
1023             {
1024             case bfd_link_hash_defined:
1025             case bfd_link_hash_defweak:
1026               return h->root.u.def.section;
1027
1028             case bfd_link_hash_common:
1029               return h->root.u.c.p->section;
1030
1031             default:
1032               break;
1033             }
1034         }
1035     }
1036   else
1037     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1038
1039   return NULL;
1040 }
1041
1042 /* Perform a relocation as part of a final link.  */
1043 static bfd_reloc_status_type
1044 mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
1045                                  input_section, contents, offset, value,
1046                                  addend, h, symndx, info, sym_sec, is_local)
1047      reloc_howto_type *howto;
1048      bfd *input_bfd;
1049      bfd *output_bfd ATTRIBUTE_UNUSED;
1050      asection *input_section;
1051      bfd_byte *contents;
1052      bfd_vma offset;
1053      bfd_vma value;
1054      bfd_vma addend;
1055      struct elf_link_hash_entry * h;
1056      unsigned long symndx;
1057      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1058      asection *sym_sec ATTRIBUTE_UNUSED;
1059      int is_local ATTRIBUTE_UNUSED;
1060 {
1061   unsigned long r_type = howto->type;
1062   bfd_byte *hit_data = contents + offset;
1063   bfd *      dynobj;
1064   bfd_vma *  local_got_offsets;
1065   asection * sgot;
1066   asection * splt;
1067   asection * sreloc;
1068
1069   dynobj = elf_hash_table (info)->dynobj;
1070   local_got_offsets = elf_local_got_offsets (input_bfd);
1071
1072   sgot   = NULL;
1073   splt   = NULL;
1074   sreloc = NULL;
1075
1076   switch (r_type)
1077     {
1078     case R_MN10300_NONE:
1079       return bfd_reloc_ok;
1080
1081     case R_MN10300_32:
1082       if (info->shared
1083           && (input_section->flags & SEC_ALLOC) != 0)
1084         {
1085           Elf_Internal_Rela outrel;
1086           bfd_boolean skip, relocate;
1087
1088           /* When generating a shared object, these relocations are
1089              copied into the output file to be resolved at run
1090              time.  */
1091           if (sreloc == NULL)
1092             {
1093               const char * name;
1094
1095               name = (bfd_elf_string_from_elf_section
1096                       (input_bfd,
1097                        elf_elfheader (input_bfd)->e_shstrndx,
1098                        elf_section_data (input_section)->rel_hdr.sh_name));
1099               if (name == NULL)
1100                 return FALSE;
1101
1102               BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1103                           && strcmp (bfd_get_section_name (input_bfd,
1104                                                            input_section),
1105                                      name + 5) == 0);
1106
1107               sreloc = bfd_get_section_by_name (dynobj, name);
1108               BFD_ASSERT (sreloc != NULL);
1109             }
1110
1111           skip = FALSE;
1112
1113           if (elf_section_data (input_section)->sec_info == NULL
1114               || (input_section->sec_info_type != ELF_INFO_TYPE_STABS))
1115             outrel.r_offset = offset;
1116           else
1117             {
1118               bfd_vma off;
1119
1120               off = (_bfd_stab_section_offset
1121                      (output_bfd, & elf_hash_table (info)->stab_info,
1122                       input_section,
1123                       & elf_section_data (input_section)->sec_info,
1124                       offset));
1125               if (off == (bfd_vma) -1)
1126                 skip = TRUE;
1127               outrel.r_offset = off;
1128             }
1129
1130           outrel.r_offset += (input_section->output_section->vma
1131                               + input_section->output_offset);
1132
1133           if (skip)
1134             {
1135               memset (&outrel, 0, sizeof outrel);
1136               relocate = FALSE;
1137             }
1138           else
1139             {
1140               /* h->dynindx may be -1 if this symbol was marked to
1141                  become local.  */
1142               if (h == NULL
1143                   || ((info->symbolic || h->dynindx == -1)
1144                       && (h->elf_link_hash_flags
1145                           & ELF_LINK_HASH_DEF_REGULAR) != 0))
1146                 {
1147                   relocate = TRUE;
1148                   outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1149                   outrel.r_addend = value + addend;
1150                 }
1151               else
1152                 {
1153                   BFD_ASSERT (h->dynindx != -1);
1154                   relocate = FALSE;
1155                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1156                   outrel.r_addend = value + addend;
1157                 }
1158             }
1159
1160           bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1161                                      (((Elf32_External_Rela *)
1162                                        sreloc->contents)
1163                                       + sreloc->reloc_count));
1164           ++sreloc->reloc_count;
1165
1166           /* If this reloc is against an external symbol, we do
1167              not want to fiddle with the addend.  Otherwise, we
1168              need to include the symbol value so that it becomes
1169              an addend for the dynamic reloc.  */
1170           if (! relocate)
1171             return bfd_reloc_ok;
1172         }
1173       value += addend;
1174       bfd_put_32 (input_bfd, value, hit_data);
1175       return bfd_reloc_ok;
1176
1177     case R_MN10300_24:
1178       value += addend;
1179
1180       if ((long) value > 0x7fffff || (long) value < -0x800000)
1181         return bfd_reloc_overflow;
1182
1183       bfd_put_8 (input_bfd, value & 0xff, hit_data);
1184       bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1185       bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1186       return bfd_reloc_ok;
1187
1188     case R_MN10300_16:
1189       value += addend;
1190
1191       if ((long) value > 0x7fff || (long) value < -0x8000)
1192         return bfd_reloc_overflow;
1193
1194       bfd_put_16 (input_bfd, value, hit_data);
1195       return bfd_reloc_ok;
1196
1197     case R_MN10300_8:
1198       value += addend;
1199
1200       if ((long) value > 0x7f || (long) value < -0x80)
1201         return bfd_reloc_overflow;
1202
1203       bfd_put_8 (input_bfd, value, hit_data);
1204       return bfd_reloc_ok;
1205
1206     case R_MN10300_PCREL8:
1207       value -= (input_section->output_section->vma
1208                 + input_section->output_offset);
1209       value -= offset;
1210       value += addend;
1211
1212       if ((long) value > 0xff || (long) value < -0x100)
1213         return bfd_reloc_overflow;
1214
1215       bfd_put_8 (input_bfd, value, hit_data);
1216       return bfd_reloc_ok;
1217
1218     case R_MN10300_PCREL16:
1219       value -= (input_section->output_section->vma
1220                 + input_section->output_offset);
1221       value -= offset;
1222       value += addend;
1223
1224       if ((long) value > 0xffff || (long) value < -0x10000)
1225         return bfd_reloc_overflow;
1226
1227       bfd_put_16 (input_bfd, value, hit_data);
1228       return bfd_reloc_ok;
1229
1230     case R_MN10300_PCREL32:
1231       if (info->shared
1232           && (input_section->flags & SEC_ALLOC) != 0
1233           && h != NULL
1234           && h->dynindx != -1
1235           && (! info->symbolic
1236               || (h->elf_link_hash_flags
1237                   & ELF_LINK_HASH_DEF_REGULAR) == 0))
1238         {
1239           Elf_Internal_Rela outrel;
1240           bfd_boolean skip;
1241
1242           /* When generating a shared object, these relocations
1243              are copied into the output file to be resolved at run
1244              time.  */
1245
1246           if (sreloc == NULL)
1247             {
1248               const char * name;
1249
1250               name = (bfd_elf_string_from_elf_section
1251                       (input_bfd,
1252                        elf_elfheader (input_bfd)->e_shstrndx,
1253                        elf_section_data (input_section)->rel_hdr.sh_name));
1254               if (name == NULL)
1255                 return FALSE;
1256
1257               BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1258                           && strcmp (bfd_get_section_name (input_bfd,
1259                                                            input_section),
1260                                      name + 5) == 0);
1261
1262               sreloc = bfd_get_section_by_name (dynobj, name);
1263               BFD_ASSERT (sreloc != NULL);
1264             }
1265
1266           skip = FALSE;
1267
1268           if (elf_section_data (input_section)->sec_info == NULL
1269               || (input_section->sec_info_type != ELF_INFO_TYPE_STABS))
1270             outrel.r_offset = offset;
1271           else
1272             {
1273               bfd_vma off;
1274
1275               off = (_bfd_stab_section_offset
1276                      (output_bfd, & elf_hash_table (info)->stab_info,
1277                       input_section,
1278                       & elf_section_data (input_section)->sec_info,
1279                       offset));
1280               if (off == (bfd_vma) -1)
1281                 skip = TRUE;
1282               outrel.r_offset = off;
1283             }
1284
1285           outrel.r_offset += (input_section->output_section->vma
1286                               + input_section->output_offset);
1287
1288           if (skip)
1289             memset (&outrel, 0, sizeof outrel);
1290           else
1291             {
1292               BFD_ASSERT (h != NULL && h->dynindx != -1);
1293               outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_PCREL32);
1294               outrel.r_addend = addend;
1295             }
1296
1297           bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1298                                      (((Elf32_External_Rela *)
1299                                        sreloc->contents)
1300                                       + sreloc->reloc_count));
1301           ++sreloc->reloc_count;
1302
1303           return bfd_reloc_ok;
1304         }
1305
1306       value -= (input_section->output_section->vma
1307                 + input_section->output_offset);
1308       value -= offset;
1309       value += addend;
1310
1311       bfd_put_32 (input_bfd, value, hit_data);
1312       return bfd_reloc_ok;
1313
1314     case R_MN10300_GNU_VTINHERIT:
1315     case R_MN10300_GNU_VTENTRY:
1316       return bfd_reloc_ok;
1317
1318     case R_MN10300_GOTPC32:
1319       /* Use global offset table as symbol value.  */
1320
1321       value = bfd_get_section_by_name (dynobj,
1322                                        ".got")->output_section->vma;
1323       value -= (input_section->output_section->vma
1324                 + input_section->output_offset);
1325       value -= offset;
1326       value += addend;
1327
1328       bfd_put_32 (input_bfd, value, hit_data);
1329       return bfd_reloc_ok;
1330
1331     case R_MN10300_GOTPC16:
1332       /* Use global offset table as symbol value.  */
1333
1334       value = bfd_get_section_by_name (dynobj,
1335                                        ".got")->output_section->vma;
1336       value -= (input_section->output_section->vma
1337                 + input_section->output_offset);
1338       value -= offset;
1339       value += addend;
1340
1341       if ((long) value > 0xffff || (long) value < -0x10000)
1342         return bfd_reloc_overflow;
1343
1344       bfd_put_16 (input_bfd, value, hit_data);
1345       return bfd_reloc_ok;
1346
1347     case R_MN10300_GOTOFF32:
1348       value -= bfd_get_section_by_name (dynobj,
1349                                         ".got")->output_section->vma;
1350       value += addend;
1351
1352       bfd_put_32 (input_bfd, value, hit_data);
1353       return bfd_reloc_ok;
1354
1355     case R_MN10300_GOTOFF24:
1356       value -= bfd_get_section_by_name (dynobj,
1357                                         ".got")->output_section->vma;
1358       value += addend;
1359
1360       if ((long) value > 0x7fffff || (long) value < -0x800000)
1361         return bfd_reloc_overflow;
1362
1363       bfd_put_8 (input_bfd, value, hit_data);
1364       bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1365       bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1366       return bfd_reloc_ok;
1367
1368     case R_MN10300_GOTOFF16:
1369       value -= bfd_get_section_by_name (dynobj,
1370                                         ".got")->output_section->vma;
1371       value += addend;
1372
1373       if ((long) value > 0xffff || (long) value < -0x10000)
1374         return bfd_reloc_overflow;
1375
1376       bfd_put_16 (input_bfd, value, hit_data);
1377       return bfd_reloc_ok;
1378
1379     case R_MN10300_PLT32:
1380       if (h != NULL
1381           && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1382           && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1383           && h->plt.offset != (bfd_vma) -1)
1384         {
1385           asection * splt;
1386
1387           splt = bfd_get_section_by_name (dynobj, ".plt");
1388
1389           value = (splt->output_section->vma
1390                    + splt->output_offset
1391                    + h->plt.offset) - value;
1392         }
1393
1394       value -= (input_section->output_section->vma
1395                 + input_section->output_offset);
1396       value -= offset;
1397       value += addend;
1398
1399       bfd_put_32 (input_bfd, value, hit_data);
1400       return bfd_reloc_ok;
1401
1402     case R_MN10300_PLT16:
1403       if (h != NULL
1404           && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1405           && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1406           && h->plt.offset != (bfd_vma) -1)
1407         {
1408           asection * splt;
1409
1410           splt = bfd_get_section_by_name (dynobj, ".plt");
1411
1412           value = (splt->output_section->vma
1413                    + splt->output_offset
1414                    + h->plt.offset) - value;
1415         }
1416
1417       value -= (input_section->output_section->vma
1418                 + input_section->output_offset);
1419       value -= offset;
1420       value += addend;
1421
1422       if ((long) value > 0xffff || (long) value < -0x10000)
1423         return bfd_reloc_overflow;
1424
1425       bfd_put_16 (input_bfd, value, hit_data);
1426       return bfd_reloc_ok;
1427
1428     case R_MN10300_GOT32:
1429     case R_MN10300_GOT24:
1430     case R_MN10300_GOT16:
1431       {
1432         asection * sgot;
1433
1434         sgot = bfd_get_section_by_name (dynobj, ".got");
1435
1436           if (h != NULL)
1437             {
1438               bfd_vma off;
1439
1440               off = h->got.offset;
1441               BFD_ASSERT (off != (bfd_vma) -1);
1442
1443               if (! elf_hash_table (info)->dynamic_sections_created
1444                   || (info->shared
1445                       && (info->symbolic || h->dynindx == -1)
1446                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1447                 /* This is actually a static link, or it is a
1448                    -Bsymbolic link and the symbol is defined
1449                    locally, or the symbol was forced to be local
1450                    because of a version file.  We must initialize
1451                    this entry in the global offset table.
1452
1453                    When doing a dynamic link, we create a .rela.got
1454                    relocation entry to initialize the value.  This
1455                    is done in the finish_dynamic_symbol routine.  */
1456                 bfd_put_32 (output_bfd, value,
1457                             sgot->contents + off);
1458
1459               value = sgot->output_offset + off;
1460             }
1461           else
1462             {
1463               bfd_vma off;
1464
1465               off = elf_local_got_offsets (input_bfd)[symndx];
1466
1467               bfd_put_32 (output_bfd, value, sgot->contents + off);
1468
1469               if (info->shared)
1470                 {
1471                   asection * srelgot;
1472                   Elf_Internal_Rela outrel;
1473
1474                   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1475                   BFD_ASSERT (srelgot != NULL);
1476
1477                   outrel.r_offset = (sgot->output_section->vma
1478                                      + sgot->output_offset
1479                                      + off);
1480                   outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1481                   outrel.r_addend = value;
1482                   bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1483                                              (((Elf32_External_Rela *)
1484                                                srelgot->contents)
1485                                               + srelgot->reloc_count));
1486                   ++ srelgot->reloc_count;
1487                 }
1488
1489               value = sgot->output_offset + off;
1490             }
1491       }
1492
1493       value += addend;
1494
1495       if (r_type == R_MN10300_GOT32)
1496         {
1497           bfd_put_32 (input_bfd, value, hit_data);
1498           return bfd_reloc_ok;
1499         }
1500       else if (r_type == R_MN10300_GOT24)
1501         {
1502           if ((long) value > 0x7fffff || (long) value < -0x800000)
1503             return bfd_reloc_overflow;
1504
1505           bfd_put_8 (input_bfd, value & 0xff, hit_data);
1506           bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1507           bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1508           return bfd_reloc_ok;
1509         }
1510       else if (r_type == R_MN10300_GOT16)
1511         {
1512           if ((long) value > 0xffff || (long) value < -0x10000)
1513             return bfd_reloc_overflow;
1514
1515           bfd_put_16 (input_bfd, value, hit_data);
1516           return bfd_reloc_ok;
1517         }
1518       /* Fall through.  */
1519
1520     default:
1521       return bfd_reloc_notsupported;
1522     }
1523 }
1524 \f
1525 /* Relocate an MN10300 ELF section.  */
1526 static bfd_boolean
1527 mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1528                               contents, relocs, local_syms, local_sections)
1529      bfd *output_bfd;
1530      struct bfd_link_info *info;
1531      bfd *input_bfd;
1532      asection *input_section;
1533      bfd_byte *contents;
1534      Elf_Internal_Rela *relocs;
1535      Elf_Internal_Sym *local_syms;
1536      asection **local_sections;
1537 {
1538   Elf_Internal_Shdr *symtab_hdr;
1539   struct elf32_mn10300_link_hash_entry **sym_hashes;
1540   Elf_Internal_Rela *rel, *relend;
1541
1542   if (info->relocatable)
1543     return TRUE;
1544
1545   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1546   sym_hashes = (struct elf32_mn10300_link_hash_entry **)
1547                  (elf_sym_hashes (input_bfd));
1548
1549   rel = relocs;
1550   relend = relocs + input_section->reloc_count;
1551   for (; rel < relend; rel++)
1552     {
1553       int r_type;
1554       reloc_howto_type *howto;
1555       unsigned long r_symndx;
1556       Elf_Internal_Sym *sym;
1557       asection *sec;
1558       struct elf32_mn10300_link_hash_entry *h;
1559       bfd_vma relocation;
1560       bfd_reloc_status_type r;
1561
1562       r_symndx = ELF32_R_SYM (rel->r_info);
1563       r_type = ELF32_R_TYPE (rel->r_info);
1564       howto = elf_mn10300_howto_table + r_type;
1565
1566       /* Just skip the vtable gc relocs.  */
1567       if (r_type == R_MN10300_GNU_VTINHERIT
1568           || r_type == R_MN10300_GNU_VTENTRY)
1569         continue;
1570
1571       h = NULL;
1572       sym = NULL;
1573       sec = NULL;
1574       if (r_symndx < symtab_hdr->sh_info)
1575         {
1576           sym = local_syms + r_symndx;
1577           sec = local_sections[r_symndx];
1578           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1579         }
1580       else
1581         {
1582           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1583           while (h->root.root.type == bfd_link_hash_indirect
1584                  || h->root.root.type == bfd_link_hash_warning)
1585             h = (struct elf32_mn10300_link_hash_entry *) h->root.root.u.i.link;
1586           if (h->root.root.type == bfd_link_hash_defined
1587               || h->root.root.type == bfd_link_hash_defweak)
1588             {
1589               sec = h->root.root.u.def.section;
1590               if (   r_type == R_MN10300_GOTPC32
1591                   || r_type == R_MN10300_GOTPC16
1592                   || ((   r_type == R_MN10300_PLT32
1593                        || r_type == R_MN10300_PLT16)
1594                       && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
1595                       && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
1596                       && h->root.plt.offset != (bfd_vma) -1)
1597                   || ((   r_type == R_MN10300_GOT32
1598                        || r_type == R_MN10300_GOT24
1599                        || r_type == R_MN10300_GOT16)
1600                       && elf_hash_table (info)->dynamic_sections_created
1601                       && (! info->shared
1602                           || (! info->symbolic && h->root.dynindx != -1)
1603                           || (h->root.elf_link_hash_flags
1604                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
1605                   || (info->shared
1606                       && ((! info->symbolic && h->root.dynindx != -1)
1607                           || (h->root.elf_link_hash_flags
1608                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
1609                       && (   r_type == R_MN10300_32
1610                           || r_type == R_MN10300_PCREL32)
1611                       && ((input_section->flags & SEC_ALLOC) != 0
1612                           /* DWARF will emit R_MN10300_32 relocations
1613                              in its sections against symbols defined
1614                              externally in shared libraries.  We can't
1615                              do anything with them here.  */
1616                           || ((input_section->flags & SEC_DEBUGGING) != 0
1617                               && (h->root.elf_link_hash_flags
1618                                   & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
1619                 {
1620                   /* In these cases, we don't need the relocation
1621                      value.  We check specially because in some
1622                      obscure cases sec->output_section will be NULL.  */
1623                   relocation = 0;
1624                 }
1625               else if (sec->output_section == NULL)
1626                 {
1627                   (*_bfd_error_handler)
1628                     (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1629                      bfd_get_filename (input_bfd), h->root.root.root.string,
1630                      bfd_get_section_name (input_bfd, input_section));
1631                   relocation = 0;
1632                 }
1633               else
1634                 relocation = (h->root.root.u.def.value
1635                               + sec->output_section->vma
1636                               + sec->output_offset);
1637             }
1638           else if (h->root.root.type == bfd_link_hash_undefweak)
1639             relocation = 0;
1640           else if (info->shared && !info->symbolic && !info->no_undefined
1641                    && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
1642             relocation = 0;
1643           else
1644             {
1645               if (! ((*info->callbacks->undefined_symbol)
1646                      (info, h->root.root.root.string, input_bfd,
1647                       input_section, rel->r_offset,
1648                       (!info->shared || info->no_undefined
1649                        || ELF_ST_VISIBILITY (h->root.other)))))
1650                 return FALSE;
1651               relocation = 0;
1652             }
1653         }
1654
1655       r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
1656                                            input_section,
1657                                            contents, rel->r_offset,
1658                                            relocation, rel->r_addend,
1659                                            (struct elf_link_hash_entry *)h,
1660                                            r_symndx,
1661                                            info, sec, h == NULL);
1662
1663       if (r != bfd_reloc_ok)
1664         {
1665           const char *name;
1666           const char *msg = (const char *) 0;
1667
1668           if (h != NULL)
1669             name = h->root.root.root.string;
1670           else
1671             {
1672               name = (bfd_elf_string_from_elf_section
1673                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1674               if (name == NULL || *name == '\0')
1675                 name = bfd_section_name (input_bfd, sec);
1676             }
1677
1678           switch (r)
1679             {
1680             case bfd_reloc_overflow:
1681               if (! ((*info->callbacks->reloc_overflow)
1682                      (info, name, howto->name, (bfd_vma) 0,
1683                       input_bfd, input_section, rel->r_offset)))
1684                 return FALSE;
1685               break;
1686
1687             case bfd_reloc_undefined:
1688               if (! ((*info->callbacks->undefined_symbol)
1689                      (info, name, input_bfd, input_section,
1690                       rel->r_offset, TRUE)))
1691                 return FALSE;
1692               break;
1693
1694             case bfd_reloc_outofrange:
1695               msg = _("internal error: out of range error");
1696               goto common_error;
1697
1698             case bfd_reloc_notsupported:
1699               msg = _("internal error: unsupported relocation error");
1700               goto common_error;
1701
1702             case bfd_reloc_dangerous:
1703               msg = _("internal error: dangerous error");
1704               goto common_error;
1705
1706             default:
1707               msg = _("internal error: unknown error");
1708               /* fall through */
1709
1710             common_error:
1711               if (!((*info->callbacks->warning)
1712                     (info, msg, name, input_bfd, input_section,
1713                      rel->r_offset)))
1714                 return FALSE;
1715               break;
1716             }
1717         }
1718     }
1719
1720   return TRUE;
1721 }
1722
1723 /* Finish initializing one hash table entry.  */
1724 static bfd_boolean
1725 elf32_mn10300_finish_hash_table_entry (gen_entry, in_args)
1726      struct bfd_hash_entry *gen_entry;
1727      PTR in_args ATTRIBUTE_UNUSED;
1728 {
1729   struct elf32_mn10300_link_hash_entry *entry;
1730   unsigned int byte_count = 0;
1731
1732   entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
1733
1734   if (entry->root.root.type == bfd_link_hash_warning)
1735     entry = (struct elf32_mn10300_link_hash_entry *) entry->root.root.u.i.link;
1736
1737   /* If we already know we want to convert "call" to "calls" for calls
1738      to this symbol, then return now.  */
1739   if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
1740     return TRUE;
1741
1742   /* If there are no named calls to this symbol, or there's nothing we
1743      can move from the function itself into the "call" instruction, then
1744      note that all "call" instructions should be converted into "calls"
1745      instructions and return.  */
1746   if (entry->direct_calls == 0
1747       || (entry->stack_size == 0 && entry->movm_args == 0))
1748     {
1749       /* Make a note that we should convert "call" instructions to "calls"
1750          instructions for calls to this symbol.  */
1751       entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1752       return TRUE;
1753     }
1754
1755   /* We may be able to move some instructions from the function itself into
1756      the "call" instruction.  Count how many bytes we might be able to
1757      eliminate in the function itself.  */
1758
1759   /* A movm instruction is two bytes.  */
1760   if (entry->movm_args)
1761     byte_count += 2;
1762
1763   /* Count the insn to allocate stack space too.  */
1764   if (entry->stack_size > 0 && entry->stack_size <= 128)
1765     byte_count += 3;
1766   else if (entry->stack_size > 0 && entry->stack_size < 256)
1767     byte_count += 4;
1768
1769   /* If using "call" will result in larger code, then turn all
1770      the associated "call" instructions into "calls" instrutions.  */
1771   if (byte_count < entry->direct_calls)
1772     entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1773
1774   /* This routine never fails.  */
1775   return TRUE;
1776 }
1777
1778 /* This function handles relaxing for the mn10300.
1779
1780    There's quite a few relaxing opportunites available on the mn10300:
1781
1782         * calls:32 -> calls:16                                     2 bytes
1783         * call:32  -> call:16                                      2 bytes
1784
1785         * call:32 -> calls:32                                      1 byte
1786         * call:16 -> calls:16                                      1 byte
1787                 * These are done anytime using "calls" would result
1788                 in smaller code, or when necessary to preserve the
1789                 meaning of the program.
1790
1791         * call:32                                                  varies
1792         * call:16
1793                 * In some circumstances we can move instructions
1794                 from a function prologue into a "call" instruction.
1795                 This is only done if the resulting code is no larger
1796                 than the original code.
1797
1798         * jmp:32 -> jmp:16                                         2 bytes
1799         * jmp:16 -> bra:8                                          1 byte
1800
1801                 * If the previous instruction is a conditional branch
1802                 around the jump/bra, we may be able to reverse its condition
1803                 and change its target to the jump's target.  The jump/bra
1804                 can then be deleted.                               2 bytes
1805
1806         * mov abs32 -> mov abs16                                   1 or 2 bytes
1807
1808         * Most instructions which accept imm32 can relax to imm16  1 or 2 bytes
1809         - Most instructions which accept imm16 can relax to imm8   1 or 2 bytes
1810
1811         * Most instructions which accept d32 can relax to d16      1 or 2 bytes
1812         - Most instructions which accept d16 can relax to d8       1 or 2 bytes
1813
1814         We don't handle imm16->imm8 or d16->d8 as they're very rare
1815         and somewhat more difficult to support.  */
1816
1817 static bfd_boolean
1818 mn10300_elf_relax_section (abfd, sec, link_info, again)
1819      bfd *abfd;
1820      asection *sec;
1821      struct bfd_link_info *link_info;
1822      bfd_boolean *again;
1823 {
1824   Elf_Internal_Shdr *symtab_hdr;
1825   Elf_Internal_Rela *internal_relocs = NULL;
1826   Elf_Internal_Rela *irel, *irelend;
1827   bfd_byte *contents = NULL;
1828   Elf_Internal_Sym *isymbuf = NULL;
1829   struct elf32_mn10300_link_hash_table *hash_table;
1830   asection *section = sec;
1831
1832   /* Assume nothing changes.  */
1833   *again = FALSE;
1834
1835   /* We need a pointer to the mn10300 specific hash table.  */
1836   hash_table = elf32_mn10300_hash_table (link_info);
1837
1838   /* Initialize fields in each hash table entry the first time through.  */
1839   if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
1840     {
1841       bfd *input_bfd;
1842
1843       /* Iterate over all the input bfds.  */
1844       for (input_bfd = link_info->input_bfds;
1845            input_bfd != NULL;
1846            input_bfd = input_bfd->link_next)
1847         {
1848           /* We're going to need all the symbols for each bfd.  */
1849           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1850           if (symtab_hdr->sh_info != 0)
1851             {
1852               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1853               if (isymbuf == NULL)
1854                 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1855                                                 symtab_hdr->sh_info, 0,
1856                                                 NULL, NULL, NULL);
1857               if (isymbuf == NULL)
1858                 goto error_return;
1859             }
1860
1861           /* Iterate over each section in this bfd.  */
1862           for (section = input_bfd->sections;
1863                section != NULL;
1864                section = section->next)
1865             {
1866               struct elf32_mn10300_link_hash_entry *hash;
1867               Elf_Internal_Sym *sym;
1868               asection *sym_sec = NULL;
1869               const char *sym_name;
1870               char *new_name;
1871
1872               /* If there's nothing to do in this section, skip it.  */
1873               if (! (((section->flags & SEC_RELOC) != 0
1874                       && section->reloc_count != 0)
1875                      || (section->flags & SEC_CODE) != 0))
1876                 continue;
1877
1878               /* Get cached copy of section contents if it exists.  */
1879               if (elf_section_data (section)->this_hdr.contents != NULL)
1880                 contents = elf_section_data (section)->this_hdr.contents;
1881               else if (section->_raw_size != 0)
1882                 {
1883                   /* Go get them off disk.  */
1884                   contents = (bfd_byte *) bfd_malloc (section->_raw_size);
1885                   if (contents == NULL)
1886                     goto error_return;
1887
1888                   if (!bfd_get_section_contents (input_bfd, section,
1889                                                  contents, (file_ptr) 0,
1890                                                  section->_raw_size))
1891                     goto error_return;
1892                 }
1893               else
1894                 contents = NULL;
1895
1896               /* If there aren't any relocs, then there's nothing to do.  */
1897               if ((section->flags & SEC_RELOC) != 0
1898                   && section->reloc_count != 0)
1899                 {
1900
1901                   /* Get a copy of the native relocations.  */
1902                   internal_relocs = (_bfd_elf_link_read_relocs
1903                                      (input_bfd, section, (PTR) NULL,
1904                                       (Elf_Internal_Rela *) NULL,
1905                                       link_info->keep_memory));
1906                   if (internal_relocs == NULL)
1907                     goto error_return;
1908
1909                   /* Now examine each relocation.  */
1910                   irel = internal_relocs;
1911                   irelend = irel + section->reloc_count;
1912                   for (; irel < irelend; irel++)
1913                     {
1914                       long r_type;
1915                       unsigned long r_index;
1916                       unsigned char code;
1917
1918                       r_type = ELF32_R_TYPE (irel->r_info);
1919                       r_index = ELF32_R_SYM (irel->r_info);
1920
1921                       if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
1922                         goto error_return;
1923
1924                       /* We need the name and hash table entry of the target
1925                          symbol!  */
1926                       hash = NULL;
1927                       sym = NULL;
1928                       sym_sec = NULL;
1929
1930                       if (r_index < symtab_hdr->sh_info)
1931                         {
1932                           /* A local symbol.  */
1933                           Elf_Internal_Sym *isym;
1934                           struct elf_link_hash_table *elftab;
1935                           bfd_size_type amt;
1936
1937                           isym = isymbuf + r_index;
1938                           if (isym->st_shndx == SHN_UNDEF)
1939                             sym_sec = bfd_und_section_ptr;
1940                           else if (isym->st_shndx == SHN_ABS)
1941                             sym_sec = bfd_abs_section_ptr;
1942                           else if (isym->st_shndx == SHN_COMMON)
1943                             sym_sec = bfd_com_section_ptr;
1944                           else
1945                             sym_sec
1946                               = bfd_section_from_elf_index (input_bfd,
1947                                                             isym->st_shndx);
1948
1949                           sym_name
1950                             = bfd_elf_string_from_elf_section (input_bfd,
1951                                                                (symtab_hdr
1952                                                                 ->sh_link),
1953                                                                isym->st_name);
1954
1955                           /* If it isn't a function, then we don't care
1956                              about it.  */
1957                           if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
1958                             continue;
1959
1960                           /* Tack on an ID so we can uniquely identify this
1961                              local symbol in the global hash table.  */
1962                           amt = strlen (sym_name) + 10;
1963                           new_name = bfd_malloc (amt);
1964                           if (new_name == 0)
1965                             goto error_return;
1966
1967                           sprintf (new_name, "%s_%08x",
1968                                    sym_name, (int) sym_sec);
1969                           sym_name = new_name;
1970
1971                           elftab = &hash_table->static_hash_table->root;
1972                           hash = ((struct elf32_mn10300_link_hash_entry *)
1973                                   elf_link_hash_lookup (elftab, sym_name,
1974                                                         TRUE, TRUE, FALSE));
1975                           free (new_name);
1976                         }
1977                       else
1978                         {
1979                           r_index -= symtab_hdr->sh_info;
1980                           hash = (struct elf32_mn10300_link_hash_entry *)
1981                                    elf_sym_hashes (input_bfd)[r_index];
1982                         }
1983
1984                       /* If this is not a "call" instruction, then we
1985                          should convert "call" instructions to "calls"
1986                          instructions.  */
1987                       code = bfd_get_8 (input_bfd,
1988                                         contents + irel->r_offset - 1);
1989                       if (code != 0xdd && code != 0xcd)
1990                         hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1991
1992                       /* If this is a jump/call, then bump the
1993                          direct_calls counter.  Else force "call" to
1994                          "calls" conversions.  */
1995                       if (r_type == R_MN10300_PCREL32
1996                           || r_type == R_MN10300_PLT32
1997                           || r_type == R_MN10300_PLT16
1998                           || r_type == R_MN10300_PCREL16)
1999                         hash->direct_calls++;
2000                       else
2001                         hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2002                     }
2003                 }
2004
2005               /* Now look at the actual contents to get the stack size,
2006                  and a list of what registers were saved in the prologue
2007                  (ie movm_args).  */
2008               if ((section->flags & SEC_CODE) != 0)
2009                 {
2010                   Elf_Internal_Sym *isym, *isymend;
2011                   unsigned int sec_shndx;
2012                   struct elf_link_hash_entry **hashes;
2013                   struct elf_link_hash_entry **end_hashes;
2014                   unsigned int symcount;
2015
2016                   sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2017                                                                  section);
2018
2019                   /* Look at each function defined in this section and
2020                      update info for that function.  */
2021                   isymend = isymbuf + symtab_hdr->sh_info;
2022                   for (isym = isymbuf; isym < isymend; isym++)
2023                     {
2024                       if (isym->st_shndx == sec_shndx
2025                           && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2026                         {
2027                           struct elf_link_hash_table *elftab;
2028                           bfd_size_type amt;
2029
2030                           if (isym->st_shndx == SHN_UNDEF)
2031                             sym_sec = bfd_und_section_ptr;
2032                           else if (isym->st_shndx == SHN_ABS)
2033                             sym_sec = bfd_abs_section_ptr;
2034                           else if (isym->st_shndx == SHN_COMMON)
2035                             sym_sec = bfd_com_section_ptr;
2036                           else
2037                             sym_sec
2038                               = bfd_section_from_elf_index (input_bfd,
2039                                                             isym->st_shndx);
2040
2041                           sym_name = (bfd_elf_string_from_elf_section
2042                                       (input_bfd, symtab_hdr->sh_link,
2043                                        isym->st_name));
2044
2045                           /* Tack on an ID so we can uniquely identify this
2046                              local symbol in the global hash table.  */
2047                           amt = strlen (sym_name) + 10;
2048                           new_name = bfd_malloc (amt);
2049                           if (new_name == 0)
2050                             goto error_return;
2051
2052                           sprintf (new_name, "%s_%08x",
2053                                    sym_name, (int) sym_sec);
2054                           sym_name = new_name;
2055
2056                           elftab = &hash_table->static_hash_table->root;
2057                           hash = ((struct elf32_mn10300_link_hash_entry *)
2058                                   elf_link_hash_lookup (elftab, sym_name,
2059                                                         TRUE, TRUE, FALSE));
2060                           free (new_name);
2061                           compute_function_info (input_bfd, hash,
2062                                                  isym->st_value, contents);
2063                         }
2064                     }
2065
2066                   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2067                               - symtab_hdr->sh_info);
2068                   hashes = elf_sym_hashes (abfd);
2069                   end_hashes = hashes + symcount;
2070                   for (; hashes < end_hashes; hashes++)
2071                     {
2072                       hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2073                       if ((hash->root.root.type == bfd_link_hash_defined
2074                            || hash->root.root.type == bfd_link_hash_defweak)
2075                           && hash->root.root.u.def.section == section
2076                           && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2077                         compute_function_info (input_bfd, hash,
2078                                                (hash)->root.root.u.def.value,
2079                                                contents);
2080                     }
2081                 }
2082
2083               /* Cache or free any memory we allocated for the relocs.  */
2084               if (internal_relocs != NULL
2085                   && elf_section_data (section)->relocs != internal_relocs)
2086                 free (internal_relocs);
2087               internal_relocs = NULL;
2088
2089               /* Cache or free any memory we allocated for the contents.  */
2090               if (contents != NULL
2091                   && elf_section_data (section)->this_hdr.contents != contents)
2092                 {
2093                   if (! link_info->keep_memory)
2094                     free (contents);
2095                   else
2096                     {
2097                       /* Cache the section contents for elf_link_input_bfd.  */
2098                       elf_section_data (section)->this_hdr.contents = contents;
2099                     }
2100                 }
2101               contents = NULL;
2102             }
2103
2104           /* Cache or free any memory we allocated for the symbols.  */
2105           if (isymbuf != NULL
2106               && symtab_hdr->contents != (unsigned char *) isymbuf)
2107             {
2108               if (! link_info->keep_memory)
2109                 free (isymbuf);
2110               else
2111                 {
2112                   /* Cache the symbols for elf_link_input_bfd.  */
2113                   symtab_hdr->contents = (unsigned char *) isymbuf;
2114                 }
2115             }
2116           isymbuf = NULL;
2117         }
2118
2119       /* Now iterate on each symbol in the hash table and perform
2120          the final initialization steps on each.  */
2121       elf32_mn10300_link_hash_traverse (hash_table,
2122                                         elf32_mn10300_finish_hash_table_entry,
2123                                         NULL);
2124       elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2125                                         elf32_mn10300_finish_hash_table_entry,
2126                                         NULL);
2127
2128       /* All entries in the hash table are fully initialized.  */
2129       hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
2130
2131       /* Now that everything has been initialized, go through each
2132          code section and delete any prologue insns which will be
2133          redundant because their operations will be performed by
2134          a "call" instruction.  */
2135       for (input_bfd = link_info->input_bfds;
2136            input_bfd != NULL;
2137            input_bfd = input_bfd->link_next)
2138         {
2139           /* We're going to need all the local symbols for each bfd.  */
2140           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2141           if (symtab_hdr->sh_info != 0)
2142             {
2143               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2144               if (isymbuf == NULL)
2145                 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2146                                                 symtab_hdr->sh_info, 0,
2147                                                 NULL, NULL, NULL);
2148               if (isymbuf == NULL)
2149                 goto error_return;
2150             }
2151
2152           /* Walk over each section in this bfd.  */
2153           for (section = input_bfd->sections;
2154                section != NULL;
2155                section = section->next)
2156             {
2157               unsigned int sec_shndx;
2158               Elf_Internal_Sym *isym, *isymend;
2159               struct elf_link_hash_entry **hashes;
2160               struct elf_link_hash_entry **end_hashes;
2161               unsigned int symcount;
2162
2163               /* Skip non-code sections and empty sections.  */
2164               if ((section->flags & SEC_CODE) == 0 || section->_raw_size == 0)
2165                 continue;
2166
2167               if (section->reloc_count != 0)
2168                 {
2169                   /* Get a copy of the native relocations.  */
2170                   internal_relocs = (_bfd_elf_link_read_relocs
2171                                      (input_bfd, section, (PTR) NULL,
2172                                       (Elf_Internal_Rela *) NULL,
2173                                       link_info->keep_memory));
2174                   if (internal_relocs == NULL)
2175                     goto error_return;
2176                 }
2177
2178               /* Get cached copy of section contents if it exists.  */
2179               if (elf_section_data (section)->this_hdr.contents != NULL)
2180                 contents = elf_section_data (section)->this_hdr.contents;
2181               else
2182                 {
2183                   /* Go get them off disk.  */
2184                   contents = (bfd_byte *) bfd_malloc (section->_raw_size);
2185                   if (contents == NULL)
2186                     goto error_return;
2187
2188                   if (!bfd_get_section_contents (input_bfd, section,
2189                                                  contents, (file_ptr) 0,
2190                                                  section->_raw_size))
2191                     goto error_return;
2192                 }
2193
2194               sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2195                                                              section);
2196
2197               /* Now look for any function in this section which needs
2198                  insns deleted from its prologue.  */
2199               isymend = isymbuf + symtab_hdr->sh_info;
2200               for (isym = isymbuf; isym < isymend; isym++)
2201                 {
2202                   struct elf32_mn10300_link_hash_entry *sym_hash;
2203                   asection *sym_sec = NULL;
2204                   const char *sym_name;
2205                   char *new_name;
2206                   struct elf_link_hash_table *elftab;
2207                   bfd_size_type amt;
2208
2209                   if (isym->st_shndx != sec_shndx)
2210                     continue;
2211
2212                   if (isym->st_shndx == SHN_UNDEF)
2213                     sym_sec = bfd_und_section_ptr;
2214                   else if (isym->st_shndx == SHN_ABS)
2215                     sym_sec = bfd_abs_section_ptr;
2216                   else if (isym->st_shndx == SHN_COMMON)
2217                     sym_sec = bfd_com_section_ptr;
2218                   else
2219                     sym_sec
2220                       = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2221
2222                   sym_name
2223                     = bfd_elf_string_from_elf_section (input_bfd,
2224                                                        symtab_hdr->sh_link,
2225                                                        isym->st_name);
2226
2227                   /* Tack on an ID so we can uniquely identify this
2228                      local symbol in the global hash table.  */
2229                   amt = strlen (sym_name) + 10;
2230                   new_name = bfd_malloc (amt);
2231                   if (new_name == 0)
2232                     goto error_return;
2233                   sprintf (new_name, "%s_%08x", sym_name, (int) sym_sec);
2234                   sym_name = new_name;
2235
2236                   elftab = &hash_table->static_hash_table->root;
2237                   sym_hash = ((struct elf32_mn10300_link_hash_entry *)
2238                               elf_link_hash_lookup (elftab, sym_name,
2239                                                     FALSE, FALSE, FALSE));
2240
2241                   free (new_name);
2242                   if (sym_hash == NULL)
2243                     continue;
2244
2245                   if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2246                       && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2247                     {
2248                       int bytes = 0;
2249
2250                       /* Note that we've changed things.  */
2251                       elf_section_data (section)->relocs = internal_relocs;
2252                       elf_section_data (section)->this_hdr.contents = contents;
2253                       symtab_hdr->contents = (unsigned char *) isymbuf;
2254
2255                       /* Count how many bytes we're going to delete.  */
2256                       if (sym_hash->movm_args)
2257                         bytes += 2;
2258
2259                       if (sym_hash->stack_size && sym_hash->stack_size <= 128)
2260                         bytes += 3;
2261                       else if (sym_hash->stack_size
2262                                && sym_hash->stack_size < 256)
2263                         bytes += 4;
2264
2265                       /* Note that we've deleted prologue bytes for this
2266                          function.  */
2267                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2268
2269                       /* Actually delete the bytes.  */
2270                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
2271                                                            section,
2272                                                            isym->st_value,
2273                                                            bytes))
2274                         goto error_return;
2275
2276                       /* Something changed.  Not strictly necessary, but
2277                          may lead to more relaxing opportunities.  */
2278                       *again = TRUE;
2279                     }
2280                 }
2281
2282               /* Look for any global functions in this section which
2283                  need insns deleted from their prologues.  */
2284               symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2285                           - symtab_hdr->sh_info);
2286               hashes = elf_sym_hashes (abfd);
2287               end_hashes = hashes + symcount;
2288               for (; hashes < end_hashes; hashes++)
2289                 {
2290                   struct elf32_mn10300_link_hash_entry *sym_hash;
2291
2292                   sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2293                   if ((sym_hash->root.root.type == bfd_link_hash_defined
2294                        || sym_hash->root.root.type == bfd_link_hash_defweak)
2295                       && sym_hash->root.root.u.def.section == section
2296                       && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2297                       && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2298                     {
2299                       int bytes = 0;
2300                       bfd_vma symval;
2301
2302                       /* Note that we've changed things.  */
2303                       elf_section_data (section)->relocs = internal_relocs;
2304                       elf_section_data (section)->this_hdr.contents = contents;
2305                       symtab_hdr->contents = (unsigned char *) isymbuf;
2306
2307                       /* Count how many bytes we're going to delete.  */
2308                       if (sym_hash->movm_args)
2309                         bytes += 2;
2310
2311                       if (sym_hash->stack_size && sym_hash->stack_size <= 128)
2312                         bytes += 3;
2313                       else if (sym_hash->stack_size
2314                                && sym_hash->stack_size < 256)
2315                         bytes += 4;
2316
2317                       /* Note that we've deleted prologue bytes for this
2318                          function.  */
2319                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2320
2321                       /* Actually delete the bytes.  */
2322                       symval = sym_hash->root.root.u.def.value;
2323                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
2324                                                            section,
2325                                                            symval,
2326                                                            bytes))
2327                         goto error_return;
2328
2329                       /* Something changed.  Not strictly necessary, but
2330                          may lead to more relaxing opportunities.  */
2331                       *again = TRUE;
2332                     }
2333                 }
2334
2335               /* Cache or free any memory we allocated for the relocs.  */
2336               if (internal_relocs != NULL
2337                   && elf_section_data (section)->relocs != internal_relocs)
2338                 free (internal_relocs);
2339               internal_relocs = NULL;
2340
2341               /* Cache or free any memory we allocated for the contents.  */
2342               if (contents != NULL
2343                   && elf_section_data (section)->this_hdr.contents != contents)
2344                 {
2345                   if (! link_info->keep_memory)
2346                     free (contents);
2347                   else
2348                     {
2349                       /* Cache the section contents for elf_link_input_bfd.  */
2350                       elf_section_data (section)->this_hdr.contents = contents;
2351                     }
2352                 }
2353               contents = NULL;
2354             }
2355
2356           /* Cache or free any memory we allocated for the symbols.  */
2357           if (isymbuf != NULL
2358               && symtab_hdr->contents != (unsigned char *) isymbuf)
2359             {
2360               if (! link_info->keep_memory)
2361                 free (isymbuf);
2362               else
2363                 {
2364                   /* Cache the symbols for elf_link_input_bfd.  */
2365                   symtab_hdr->contents = (unsigned char *) isymbuf;
2366                 }
2367             }
2368           isymbuf = NULL;
2369         }
2370     }
2371
2372   /* (Re)initialize for the basic instruction shortening/relaxing pass.  */
2373   contents = NULL;
2374   internal_relocs = NULL;
2375   isymbuf = NULL;
2376   /* For error_return.  */
2377   section = sec;
2378
2379   /* We don't have to do anything for a relocatable link, if
2380      this section does not have relocs, or if this is not a
2381      code section.  */
2382   if (link_info->relocatable
2383       || (sec->flags & SEC_RELOC) == 0
2384       || sec->reloc_count == 0
2385       || (sec->flags & SEC_CODE) == 0)
2386     return TRUE;
2387
2388   /* If this is the first time we have been called for this section,
2389      initialize the cooked size.  */
2390   if (sec->_cooked_size == 0)
2391     sec->_cooked_size = sec->_raw_size;
2392
2393   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2394
2395   /* Get a copy of the native relocations.  */
2396   internal_relocs = (_bfd_elf_link_read_relocs
2397                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2398                       link_info->keep_memory));
2399   if (internal_relocs == NULL)
2400     goto error_return;
2401
2402   /* Walk through them looking for relaxing opportunities.  */
2403   irelend = internal_relocs + sec->reloc_count;
2404   for (irel = internal_relocs; irel < irelend; irel++)
2405     {
2406       bfd_vma symval;
2407       struct elf32_mn10300_link_hash_entry *h = NULL;
2408
2409       /* If this isn't something that can be relaxed, then ignore
2410          this reloc.  */
2411       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
2412           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
2413           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
2414         continue;
2415
2416       /* Get the section contents if we haven't done so already.  */
2417       if (contents == NULL)
2418         {
2419           /* Get cached copy if it exists.  */
2420           if (elf_section_data (sec)->this_hdr.contents != NULL)
2421             contents = elf_section_data (sec)->this_hdr.contents;
2422           else
2423             {
2424               /* Go get them off disk.  */
2425               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2426               if (contents == NULL)
2427                 goto error_return;
2428
2429               if (! bfd_get_section_contents (abfd, sec, contents,
2430                                               (file_ptr) 0, sec->_raw_size))
2431                 goto error_return;
2432             }
2433         }
2434
2435       /* Read this BFD's symbols if we haven't done so already.  */
2436       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2437         {
2438           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2439           if (isymbuf == NULL)
2440             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2441                                             symtab_hdr->sh_info, 0,
2442                                             NULL, NULL, NULL);
2443           if (isymbuf == NULL)
2444             goto error_return;
2445         }
2446
2447       /* Get the value of the symbol referred to by the reloc.  */
2448       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2449         {
2450           Elf_Internal_Sym *isym;
2451           asection *sym_sec = NULL;
2452           const char *sym_name;
2453           char *new_name;
2454
2455           /* A local symbol.  */
2456           isym = isymbuf + ELF32_R_SYM (irel->r_info);
2457           if (isym->st_shndx == SHN_UNDEF)
2458             sym_sec = bfd_und_section_ptr;
2459           else if (isym->st_shndx == SHN_ABS)
2460             sym_sec = bfd_abs_section_ptr;
2461           else if (isym->st_shndx == SHN_COMMON)
2462             sym_sec = bfd_com_section_ptr;
2463           else
2464             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2465
2466           symval = (isym->st_value
2467                     + sym_sec->output_section->vma
2468                     + sym_sec->output_offset);
2469           sym_name = bfd_elf_string_from_elf_section (abfd,
2470                                                       symtab_hdr->sh_link,
2471                                                       isym->st_name);
2472
2473           /* Tack on an ID so we can uniquely identify this
2474              local symbol in the global hash table.  */
2475           new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
2476           if (new_name == 0)
2477             goto error_return;
2478           sprintf (new_name, "%s_%08x", sym_name, (int) sym_sec);
2479           sym_name = new_name;
2480
2481           h = (struct elf32_mn10300_link_hash_entry *)
2482                 elf_link_hash_lookup (&hash_table->static_hash_table->root,
2483                                       sym_name, FALSE, FALSE, FALSE);
2484           free (new_name);
2485         }
2486       else
2487         {
2488           unsigned long indx;
2489
2490           /* An external symbol.  */
2491           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2492           h = (struct elf32_mn10300_link_hash_entry *)
2493                 (elf_sym_hashes (abfd)[indx]);
2494           BFD_ASSERT (h != NULL);
2495           if (h->root.root.type != bfd_link_hash_defined
2496               && h->root.root.type != bfd_link_hash_defweak)
2497             {
2498               /* This appears to be a reference to an undefined
2499                 symbol.  Just ignore it--it will be caught by the
2500                 regular reloc processing.  */
2501               continue;
2502             }
2503
2504           symval = (h->root.root.u.def.value
2505                     + h->root.root.u.def.section->output_section->vma
2506                     + h->root.root.u.def.section->output_offset);
2507         }
2508
2509       /* For simplicity of coding, we are going to modify the section
2510          contents, the section relocs, and the BFD symbol table.  We
2511          must tell the rest of the code not to free up this
2512          information.  It would be possible to instead create a table
2513          of changes which have to be made, as is done in coff-mips.c;
2514          that would be more work, but would require less memory when
2515          the linker is run.  */
2516
2517       /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2518          branch/call, also deal with "call" -> "calls" conversions and
2519          insertion of prologue data into "call" instructions.  */
2520       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
2521           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
2522         {
2523           bfd_vma value = symval;
2524
2525           if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
2526               && h != NULL
2527               && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2528               && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2529               && h->root.plt.offset != (bfd_vma) -1)
2530             {
2531               asection * splt;
2532
2533               splt = bfd_get_section_by_name (elf_hash_table (link_info)
2534                                               ->dynobj, ".plt");
2535
2536               value = ((splt->output_section->vma
2537                         + splt->output_offset
2538                         + h->root.plt.offset)
2539                        - (sec->output_section->vma
2540                           + sec->output_offset
2541                           + irel->r_offset));
2542             }
2543
2544           /* If we've got a "call" instruction that needs to be turned
2545              into a "calls" instruction, do so now.  It saves a byte.  */
2546           if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2547             {
2548               unsigned char code;
2549
2550               /* Get the opcode.  */
2551               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2552
2553               /* Make sure we're working with a "call" instruction!  */
2554               if (code == 0xdd)
2555                 {
2556                   /* Note that we've changed the relocs, section contents,
2557                      etc.  */
2558                   elf_section_data (sec)->relocs = internal_relocs;
2559                   elf_section_data (sec)->this_hdr.contents = contents;
2560                   symtab_hdr->contents = (unsigned char *) isymbuf;
2561
2562                   /* Fix the opcode.  */
2563                   bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
2564                   bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2565
2566                   /* Fix irel->r_offset and irel->r_addend.  */
2567                   irel->r_offset += 1;
2568                   irel->r_addend += 1;
2569
2570                   /* Delete one byte of data.  */
2571                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2572                                                        irel->r_offset + 3, 1))
2573                     goto error_return;
2574
2575                   /* That will change things, so, we should relax again.
2576                      Note that this is not required, and it may be slow.  */
2577                   *again = TRUE;
2578                 }
2579             }
2580           else if (h)
2581             {
2582               /* We've got a "call" instruction which needs some data
2583                  from target function filled in.  */
2584               unsigned char code;
2585
2586               /* Get the opcode.  */
2587               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2588
2589               /* Insert data from the target function into the "call"
2590                  instruction if needed.  */
2591               if (code == 0xdd)
2592                 {
2593                   bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
2594                   bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2595                              contents + irel->r_offset + 5);
2596                 }
2597             }
2598
2599           /* Deal with pc-relative gunk.  */
2600           value -= (sec->output_section->vma + sec->output_offset);
2601           value -= irel->r_offset;
2602           value += irel->r_addend;
2603
2604           /* See if the value will fit in 16 bits, note the high value is
2605              0x7fff + 2 as the target will be two bytes closer if we are
2606              able to relax.  */
2607           if ((long) value < 0x8001 && (long) value > -0x8000)
2608             {
2609               unsigned char code;
2610
2611               /* Get the opcode.  */
2612               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2613
2614               if (code != 0xdc && code != 0xdd && code != 0xff)
2615                 continue;
2616
2617               /* Note that we've changed the relocs, section contents, etc.  */
2618               elf_section_data (sec)->relocs = internal_relocs;
2619               elf_section_data (sec)->this_hdr.contents = contents;
2620               symtab_hdr->contents = (unsigned char *) isymbuf;
2621
2622               /* Fix the opcode.  */
2623               if (code == 0xdc)
2624                 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
2625               else if (code == 0xdd)
2626                 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
2627               else if (code == 0xff)
2628                 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2629
2630               /* Fix the relocation's type.  */
2631               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2632                                            (ELF32_R_TYPE (irel->r_info)
2633                                             == (int) R_MN10300_PLT32)
2634                                            ? R_MN10300_PLT16 :
2635                                            R_MN10300_PCREL16);
2636
2637               /* Delete two bytes of data.  */
2638               if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2639                                                    irel->r_offset + 1, 2))
2640                 goto error_return;
2641
2642               /* That will change things, so, we should relax again.
2643                  Note that this is not required, and it may be slow.  */
2644               *again = TRUE;
2645             }
2646         }
2647
2648       /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
2649          branch.  */
2650       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
2651         {
2652           bfd_vma value = symval;
2653
2654           /* If we've got a "call" instruction that needs to be turned
2655              into a "calls" instruction, do so now.  It saves a byte.  */
2656           if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2657             {
2658               unsigned char code;
2659
2660               /* Get the opcode.  */
2661               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2662
2663               /* Make sure we're working with a "call" instruction!  */
2664               if (code == 0xcd)
2665                 {
2666                   /* Note that we've changed the relocs, section contents,
2667                      etc.  */
2668                   elf_section_data (sec)->relocs = internal_relocs;
2669                   elf_section_data (sec)->this_hdr.contents = contents;
2670                   symtab_hdr->contents = (unsigned char *) isymbuf;
2671
2672                   /* Fix the opcode.  */
2673                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
2674                   bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2675
2676                   /* Fix irel->r_offset and irel->r_addend.  */
2677                   irel->r_offset += 1;
2678                   irel->r_addend += 1;
2679
2680                   /* Delete one byte of data.  */
2681                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2682                                                        irel->r_offset + 1, 1))
2683                     goto error_return;
2684
2685                   /* That will change things, so, we should relax again.
2686                      Note that this is not required, and it may be slow.  */
2687                   *again = TRUE;
2688                 }
2689             }
2690           else if (h)
2691             {
2692               unsigned char code;
2693
2694               /* Get the opcode.  */
2695               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2696
2697               /* Insert data from the target function into the "call"
2698                  instruction if needed.  */
2699               if (code == 0xcd)
2700                 {
2701                   bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
2702                   bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2703                              contents + irel->r_offset + 3);
2704                 }
2705             }
2706
2707           /* Deal with pc-relative gunk.  */
2708           value -= (sec->output_section->vma + sec->output_offset);
2709           value -= irel->r_offset;
2710           value += irel->r_addend;
2711
2712           /* See if the value will fit in 8 bits, note the high value is
2713              0x7f + 1 as the target will be one bytes closer if we are
2714              able to relax.  */
2715           if ((long) value < 0x80 && (long) value > -0x80)
2716             {
2717               unsigned char code;
2718
2719               /* Get the opcode.  */
2720               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2721
2722               if (code != 0xcc)
2723                 continue;
2724
2725               /* Note that we've changed the relocs, section contents, etc.  */
2726               elf_section_data (sec)->relocs = internal_relocs;
2727               elf_section_data (sec)->this_hdr.contents = contents;
2728               symtab_hdr->contents = (unsigned char *) isymbuf;
2729
2730               /* Fix the opcode.  */
2731               bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
2732
2733               /* Fix the relocation's type.  */
2734               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2735                                            R_MN10300_PCREL8);
2736
2737               /* Delete one byte of data.  */
2738               if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2739                                                    irel->r_offset + 1, 1))
2740                 goto error_return;
2741
2742               /* That will change things, so, we should relax again.
2743                  Note that this is not required, and it may be slow.  */
2744               *again = TRUE;
2745             }
2746         }
2747
2748       /* Try to eliminate an unconditional 8 bit pc-relative branch
2749          which immediately follows a conditional 8 bit pc-relative
2750          branch around the unconditional branch.
2751
2752             original:           new:
2753             bCC lab1            bCC' lab2
2754             bra lab2
2755            lab1:               lab1:
2756
2757          This happens when the bCC can't reach lab2 at assembly time,
2758          but due to other relaxations it can reach at link time.  */
2759       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
2760         {
2761           Elf_Internal_Rela *nrel;
2762           bfd_vma value = symval;
2763           unsigned char code;
2764
2765           /* Deal with pc-relative gunk.  */
2766           value -= (sec->output_section->vma + sec->output_offset);
2767           value -= irel->r_offset;
2768           value += irel->r_addend;
2769
2770           /* Do nothing if this reloc is the last byte in the section.  */
2771           if (irel->r_offset == sec->_cooked_size)
2772             continue;
2773
2774           /* See if the next instruction is an unconditional pc-relative
2775              branch, more often than not this test will fail, so we
2776              test it first to speed things up.  */
2777           code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2778           if (code != 0xca)
2779             continue;
2780
2781           /* Also make sure the next relocation applies to the next
2782              instruction and that it's a pc-relative 8 bit branch.  */
2783           nrel = irel + 1;
2784           if (nrel == irelend
2785               || irel->r_offset + 2 != nrel->r_offset
2786               || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
2787             continue;
2788
2789           /* Make sure our destination immediately follows the
2790              unconditional branch.  */
2791           if (symval != (sec->output_section->vma + sec->output_offset
2792                          + irel->r_offset + 3))
2793             continue;
2794
2795           /* Now make sure we are a conditional branch.  This may not
2796              be necessary, but why take the chance.
2797
2798              Note these checks assume that R_MN10300_PCREL8 relocs
2799              only occur on bCC and bCCx insns.  If they occured
2800              elsewhere, we'd need to know the start of this insn
2801              for this check to be accurate.  */
2802           code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2803           if (code != 0xc0 && code != 0xc1 && code != 0xc2
2804               && code != 0xc3 && code != 0xc4 && code != 0xc5
2805               && code != 0xc6 && code != 0xc7 && code != 0xc8
2806               && code != 0xc9 && code != 0xe8 && code != 0xe9
2807               && code != 0xea && code != 0xeb)
2808             continue;
2809
2810           /* We also have to be sure there is no symbol/label
2811              at the unconditional branch.  */
2812           if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
2813                                             irel->r_offset + 1))
2814             continue;
2815
2816           /* Note that we've changed the relocs, section contents, etc.  */
2817           elf_section_data (sec)->relocs = internal_relocs;
2818           elf_section_data (sec)->this_hdr.contents = contents;
2819           symtab_hdr->contents = (unsigned char *) isymbuf;
2820
2821           /* Reverse the condition of the first branch.  */
2822           switch (code)
2823             {
2824             case 0xc8:
2825               code = 0xc9;
2826               break;
2827             case 0xc9:
2828               code = 0xc8;
2829               break;
2830             case 0xc0:
2831               code = 0xc2;
2832               break;
2833             case 0xc2:
2834               code = 0xc0;
2835               break;
2836             case 0xc3:
2837               code = 0xc1;
2838               break;
2839             case 0xc1:
2840               code = 0xc3;
2841               break;
2842             case 0xc4:
2843               code = 0xc6;
2844               break;
2845             case 0xc6:
2846               code = 0xc4;
2847               break;
2848             case 0xc7:
2849               code = 0xc5;
2850               break;
2851             case 0xc5:
2852               code = 0xc7;
2853               break;
2854             case 0xe8:
2855               code = 0xe9;
2856               break;
2857             case 0x9d:
2858               code = 0xe8;
2859               break;
2860             case 0xea:
2861               code = 0xeb;
2862               break;
2863             case 0xeb:
2864               code = 0xea;
2865               break;
2866             }
2867           bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2868
2869           /* Set the reloc type and symbol for the first branch
2870              from the second branch.  */
2871           irel->r_info = nrel->r_info;
2872
2873           /* Make the reloc for the second branch a null reloc.  */
2874           nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
2875                                        R_MN10300_NONE);
2876
2877           /* Delete two bytes of data.  */
2878           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2879                                                irel->r_offset + 1, 2))
2880             goto error_return;
2881
2882           /* That will change things, so, we should relax again.
2883              Note that this is not required, and it may be slow.  */
2884           *again = TRUE;
2885         }
2886
2887       /* Try to turn a 24 immediate, displacement or absolute address
2888          into a 8 immediate, displacement or absolute address.  */
2889       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
2890         {
2891           bfd_vma value = symval;
2892           value += irel->r_addend;
2893
2894           /* See if the value will fit in 8 bits.  */
2895           if ((long) value < 0x7f && (long) value > -0x80)
2896             {
2897               unsigned char code;
2898
2899               /* AM33 insns which have 24 operands are 6 bytes long and
2900                  will have 0xfd as the first byte.  */
2901
2902               /* Get the first opcode.  */
2903               code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
2904
2905               if (code == 0xfd)
2906                 {
2907                   /* Get the second opcode.  */
2908                   code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
2909
2910                   /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
2911                      equivalent instructions exists.  */
2912                   if (code != 0x6b && code != 0x7b
2913                       && code != 0x8b && code != 0x9b
2914                       && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
2915                           || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
2916                           || (code & 0x0f) == 0x0e))
2917                     {
2918                       /* Not safe if the high bit is on as relaxing may
2919                          move the value out of high mem and thus not fit
2920                          in a signed 8bit value.  This is currently over
2921                          conservative.  */
2922                       if ((value & 0x80) == 0)
2923                         {
2924                           /* Note that we've changed the relocation contents,
2925                              etc.  */
2926                           elf_section_data (sec)->relocs = internal_relocs;
2927                           elf_section_data (sec)->this_hdr.contents = contents;
2928                           symtab_hdr->contents = (unsigned char *) isymbuf;
2929
2930                           /* Fix the opcode.  */
2931                           bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
2932                           bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2933
2934                           /* Fix the relocation's type.  */
2935                           irel->r_info =
2936                             ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2937                                           R_MN10300_8);
2938
2939                           /* Delete two bytes of data.  */
2940                           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2941                                                                irel->r_offset + 1, 2))
2942                             goto error_return;
2943
2944                           /* That will change things, so, we should relax
2945                              again.  Note that this is not required, and it
2946                              may be slow.  */
2947                           *again = TRUE;
2948                           break;
2949                         }
2950                     }
2951                 }
2952             }
2953         }
2954
2955       /* Try to turn a 32bit immediate, displacement or absolute address
2956          into a 16bit immediate, displacement or absolute address.  */
2957       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
2958           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
2959           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32
2960           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
2961         {
2962           bfd_vma value = symval;
2963
2964           if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
2965             {
2966               asection * sgot;
2967
2968               sgot = bfd_get_section_by_name (elf_hash_table (link_info)
2969                                               ->dynobj, ".got");
2970
2971               if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
2972                 {
2973                   value = sgot->output_offset;
2974
2975                   if (h)
2976                     value += h->root.got.offset;
2977                   else
2978                     value += (elf_local_got_offsets
2979                               (abfd)[ELF32_R_SYM (irel->r_info)]);
2980                 }
2981               else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
2982                 value -= sgot->output_section->vma;
2983               else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
2984                 value = (sgot->output_section->vma
2985                          - (sec->output_section->vma
2986                             + sec->output_offset
2987                             + irel->r_offset));
2988               else
2989                 abort ();
2990             }
2991
2992           value += irel->r_addend;
2993
2994           /* See if the value will fit in 24 bits.
2995              We allow any 16bit match here.  We prune those we can't
2996              handle below.  */
2997           if ((long) value < 0x7fffff && (long) value > -0x800000)
2998             {
2999               unsigned char code;
3000
3001               /* AM33 insns which have 32bit operands are 7 bytes long and
3002                  will have 0xfe as the first byte.  */
3003
3004               /* Get the first opcode.  */
3005               code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3006
3007               if (code == 0xfe)
3008                 {
3009                   /* Get the second opcode.  */
3010                   code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3011
3012                   /* All the am33 32 -> 24 relaxing possibilities.  */
3013                   /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3014                      equivalent instructions exists.  */
3015                   if (code != 0x6b && code != 0x7b
3016                       && code != 0x8b && code != 0x9b
3017                       && (ELF32_R_TYPE (irel->r_info)
3018                           != (int) R_MN10300_GOTPC32)
3019                       && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3020                           || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3021                           || (code & 0x0f) == 0x0e))
3022                     {
3023                       /* Not safe if the high bit is on as relaxing may
3024                          move the value out of high mem and thus not fit
3025                          in a signed 16bit value.  This is currently over
3026                          conservative.  */
3027                       if ((value & 0x8000) == 0)
3028                         {
3029                           /* Note that we've changed the relocation contents,
3030                              etc.  */
3031                           elf_section_data (sec)->relocs = internal_relocs;
3032                           elf_section_data (sec)->this_hdr.contents = contents;
3033                           symtab_hdr->contents = (unsigned char *) isymbuf;
3034
3035                           /* Fix the opcode.  */
3036                           bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3037                           bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3038
3039                           /* Fix the relocation's type.  */
3040                           irel->r_info =
3041                             ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3042                                           (ELF32_R_TYPE (irel->r_info)
3043                                            == (int) R_MN10300_GOTOFF32)
3044                                           ? R_MN10300_GOTOFF24
3045                                           : (ELF32_R_TYPE (irel->r_info)
3046                                              == (int) R_MN10300_GOT32)
3047                                           ? R_MN10300_GOT24 :
3048                                           R_MN10300_24);
3049
3050                           /* Delete one byte of data.  */
3051                           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3052                                                                irel->r_offset + 3, 1))
3053                             goto error_return;
3054
3055                           /* That will change things, so, we should relax
3056                              again.  Note that this is not required, and it
3057                              may be slow.  */
3058                           *again = TRUE;
3059                           break;
3060                         }
3061                     }
3062                 }
3063             }
3064
3065           /* See if the value will fit in 16 bits.
3066              We allow any 16bit match here.  We prune those we can't
3067              handle below.  */
3068           if ((long) value < 0x7fff && (long) value > -0x8000)
3069             {
3070               unsigned char code;
3071
3072               /* Most insns which have 32bit operands are 6 bytes long;
3073                  exceptions are pcrel insns and bit insns.
3074
3075                  We handle pcrel insns above.  We don't bother trying
3076                  to handle the bit insns here.
3077
3078                  The first byte of the remaining insns will be 0xfc.  */
3079
3080               /* Get the first opcode.  */
3081               code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3082
3083               if (code != 0xfc)
3084                 continue;
3085
3086               /* Get the second opcode.  */
3087               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3088
3089               if ((code & 0xf0) < 0x80)
3090                 switch (code & 0xf0)
3091                   {
3092                   /* mov (d32,am),dn   -> mov (d32,am),dn
3093                      mov dm,(d32,am)   -> mov dn,(d32,am)
3094                      mov (d32,am),an   -> mov (d32,am),an
3095                      mov dm,(d32,am)   -> mov dn,(d32,am)
3096                      movbu (d32,am),dn -> movbu (d32,am),dn
3097                      movbu dm,(d32,am) -> movbu dn,(d32,am)
3098                      movhu (d32,am),dn -> movhu (d32,am),dn
3099                      movhu dm,(d32,am) -> movhu dn,(d32,am) */
3100                   case 0x00:
3101                   case 0x10:
3102                   case 0x20:
3103                   case 0x30:
3104                   case 0x40:
3105                   case 0x50:
3106                   case 0x60:
3107                   case 0x70:
3108                     /* Not safe if the high bit is on as relaxing may
3109                        move the value out of high mem and thus not fit
3110                        in a signed 16bit value.  */
3111                     if (code == 0xcc
3112                         && (value & 0x8000))
3113                       continue;
3114
3115                     /* Note that we've changed the relocation contents, etc.  */
3116                     elf_section_data (sec)->relocs = internal_relocs;
3117                     elf_section_data (sec)->this_hdr.contents = contents;
3118                     symtab_hdr->contents = (unsigned char *) isymbuf;
3119
3120                     /* Fix the opcode.  */
3121                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3122                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3123
3124                     /* Fix the relocation's type.  */
3125                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3126                                                  (ELF32_R_TYPE (irel->r_info)
3127                                                   == (int) R_MN10300_GOTOFF32)
3128                                                  ? R_MN10300_GOTOFF16
3129                                                  : (ELF32_R_TYPE (irel->r_info)
3130                                                     == (int) R_MN10300_GOT32)
3131                                                  ? R_MN10300_GOT16
3132                                                  : (ELF32_R_TYPE (irel->r_info)
3133                                                     == (int) R_MN10300_GOTPC32)
3134                                                  ? R_MN10300_GOTPC16 :
3135                                                  R_MN10300_16);
3136
3137                     /* Delete two bytes of data.  */
3138                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3139                                                          irel->r_offset + 2, 2))
3140                       goto error_return;
3141
3142                     /* That will change things, so, we should relax again.
3143                        Note that this is not required, and it may be slow.  */
3144                     *again = TRUE;
3145                     break;
3146                   }
3147               else if ((code & 0xf0) == 0x80
3148                        || (code & 0xf0) == 0x90)
3149                 switch (code & 0xf3)
3150                   {
3151                   /* mov dn,(abs32)   -> mov dn,(abs16)
3152                      movbu dn,(abs32) -> movbu dn,(abs16)
3153                      movhu dn,(abs32) -> movhu dn,(abs16)  */
3154                   case 0x81:
3155                   case 0x82:
3156                   case 0x83:
3157                     /* Note that we've changed the relocation contents, etc.  */
3158                     elf_section_data (sec)->relocs = internal_relocs;
3159                     elf_section_data (sec)->this_hdr.contents = contents;
3160                     symtab_hdr->contents = (unsigned char *) isymbuf;
3161
3162                     if ((code & 0xf3) == 0x81)
3163                       code = 0x01 + (code & 0x0c);
3164                     else if ((code & 0xf3) == 0x82)
3165                       code = 0x02 + (code & 0x0c);
3166                     else if ((code & 0xf3) == 0x83)
3167                       code = 0x03 + (code & 0x0c);
3168                     else
3169                       abort ();
3170
3171                     /* Fix the opcode.  */
3172                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3173
3174                     /* Fix the relocation's type.  */
3175                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3176                                                  (ELF32_R_TYPE (irel->r_info)
3177                                                   == (int) R_MN10300_GOTOFF32)
3178                                                  ? R_MN10300_GOTOFF16
3179                                                  : (ELF32_R_TYPE (irel->r_info)
3180                                                     == (int) R_MN10300_GOT32)
3181                                                  ? R_MN10300_GOT16
3182                                                  : (ELF32_R_TYPE (irel->r_info)
3183                                                     == (int) R_MN10300_GOTPC32)
3184                                                  ? R_MN10300_GOTPC16 :
3185                                                  R_MN10300_16);
3186
3187                     /* The opcode got shorter too, so we have to fix the
3188                        addend and offset too!  */
3189                     irel->r_offset -= 1;
3190
3191                     /* Delete three bytes of data.  */
3192                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3193                                                          irel->r_offset + 1, 3))
3194                       goto error_return;
3195
3196                     /* That will change things, so, we should relax again.
3197                        Note that this is not required, and it may be slow.  */
3198                     *again = TRUE;
3199                     break;
3200
3201                   /* mov am,(abs32)    -> mov am,(abs16)
3202                      mov am,(d32,sp)   -> mov am,(d16,sp)
3203                      mov dm,(d32,sp)   -> mov dm,(d32,sp)
3204                      movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3205                      movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3206                   case 0x80:
3207                   case 0x90:
3208                   case 0x91:
3209                   case 0x92:
3210                   case 0x93:
3211                     /* sp-based offsets are zero-extended.  */
3212                     if (code >= 0x90 && code <= 0x93
3213                         && (long)value < 0)
3214                       continue;
3215
3216                     /* Note that we've changed the relocation contents, etc.  */
3217                     elf_section_data (sec)->relocs = internal_relocs;
3218                     elf_section_data (sec)->this_hdr.contents = contents;
3219                     symtab_hdr->contents = (unsigned char *) isymbuf;
3220
3221                     /* Fix the opcode.  */
3222                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3223                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3224
3225                     /* Fix the relocation's type.  */
3226                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3227                                                  (ELF32_R_TYPE (irel->r_info)
3228                                                   == (int) R_MN10300_GOTOFF32)
3229                                                  ? R_MN10300_GOTOFF16
3230                                                  : (ELF32_R_TYPE (irel->r_info)
3231                                                     == (int) R_MN10300_GOT32)
3232                                                  ? R_MN10300_GOT16
3233                                                  : (ELF32_R_TYPE (irel->r_info)
3234                                                     == (int) R_MN10300_GOTPC32)
3235                                                  ? R_MN10300_GOTPC16 :
3236                                                  R_MN10300_16);
3237
3238                     /* Delete two bytes of data.  */
3239                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3240                                                          irel->r_offset + 2, 2))
3241                       goto error_return;
3242
3243                     /* That will change things, so, we should relax again.
3244                        Note that this is not required, and it may be slow.  */
3245                     *again = TRUE;
3246                     break;
3247                   }
3248               else if ((code & 0xf0) < 0xf0)
3249                 switch (code & 0xfc)
3250                   {
3251                   /* mov imm32,dn     -> mov imm16,dn
3252                      mov imm32,an     -> mov imm16,an
3253                      mov (abs32),dn   -> mov (abs16),dn
3254                      movbu (abs32),dn -> movbu (abs16),dn
3255                      movhu (abs32),dn -> movhu (abs16),dn  */
3256                   case 0xcc:
3257                   case 0xdc:
3258                   case 0xa4:
3259                   case 0xa8:
3260                   case 0xac:
3261                     /* Not safe if the high bit is on as relaxing may
3262                        move the value out of high mem and thus not fit
3263                        in a signed 16bit value.  */
3264                     if (code == 0xcc
3265                         && (value & 0x8000))
3266                       continue;
3267
3268                     /* mov imm16, an zero-extends the immediate.  */
3269                     if (code == 0xdc
3270                         && (long)value < 0)
3271                       continue;
3272
3273                     /* Note that we've changed the relocation contents, etc.  */
3274                     elf_section_data (sec)->relocs = internal_relocs;
3275                     elf_section_data (sec)->this_hdr.contents = contents;
3276                     symtab_hdr->contents = (unsigned char *) isymbuf;
3277
3278                     if ((code & 0xfc) == 0xcc)
3279                       code = 0x2c + (code & 0x03);
3280                     else if ((code & 0xfc) == 0xdc)
3281                       code = 0x24 + (code & 0x03);
3282                     else if ((code & 0xfc) == 0xa4)
3283                       code = 0x30 + (code & 0x03);
3284                     else if ((code & 0xfc) == 0xa8)
3285                       code = 0x34 + (code & 0x03);
3286                     else if ((code & 0xfc) == 0xac)
3287                       code = 0x38 + (code & 0x03);
3288                     else
3289                       abort ();
3290
3291                     /* Fix the opcode.  */
3292                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3293
3294                     /* Fix the relocation's type.  */
3295                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3296                                                  (ELF32_R_TYPE (irel->r_info)
3297                                                   == (int) R_MN10300_GOTOFF32)
3298                                                  ? R_MN10300_GOTOFF16
3299                                                  : (ELF32_R_TYPE (irel->r_info)
3300                                                     == (int) R_MN10300_GOT32)
3301                                                  ? R_MN10300_GOT16
3302                                                  : (ELF32_R_TYPE (irel->r_info)
3303                                                     == (int) R_MN10300_GOTPC32)
3304                                                  ? R_MN10300_GOTPC16 :
3305                                                  R_MN10300_16);
3306
3307                     /* The opcode got shorter too, so we have to fix the
3308                        addend and offset too!  */
3309                     irel->r_offset -= 1;
3310
3311                     /* Delete three bytes of data.  */
3312                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3313                                                          irel->r_offset + 1, 3))
3314                       goto error_return;
3315
3316                     /* That will change things, so, we should relax again.
3317                        Note that this is not required, and it may be slow.  */
3318                     *again = TRUE;
3319                     break;
3320
3321                   /* mov (abs32),an    -> mov (abs16),an
3322                      mov (d32,sp),an   -> mov (d16,sp),an
3323                      mov (d32,sp),dn   -> mov (d16,sp),dn
3324                      movbu (d32,sp),dn -> movbu (d16,sp),dn
3325                      movhu (d32,sp),dn -> movhu (d16,sp),dn
3326                      add imm32,dn      -> add imm16,dn
3327                      cmp imm32,dn      -> cmp imm16,dn
3328                      add imm32,an      -> add imm16,an
3329                      cmp imm32,an      -> cmp imm16,an
3330                      and imm32,dn      -> and imm16,dn
3331                      or imm32,dn       -> or imm16,dn
3332                      xor imm32,dn      -> xor imm16,dn
3333                      btst imm32,dn     -> btst imm16,dn */
3334
3335                   case 0xa0:
3336                   case 0xb0:
3337                   case 0xb1:
3338                   case 0xb2:
3339                   case 0xb3:
3340                   case 0xc0:
3341                   case 0xc8:
3342
3343                   case 0xd0:
3344                   case 0xd8:
3345                   case 0xe0:
3346                   case 0xe1:
3347                   case 0xe2:
3348                   case 0xe3:
3349                     /* cmp imm16, an zero-extends the immediate.  */
3350                     if (code == 0xdc
3351                         && (long)value < 0)
3352                       continue;
3353
3354                     /* So do sp-based offsets.  */
3355                     if (code >= 0xb0 && code <= 0xb3
3356                         && (long)value < 0)
3357                       continue;
3358
3359                     /* Note that we've changed the relocation contents, etc.  */
3360                     elf_section_data (sec)->relocs = internal_relocs;
3361                     elf_section_data (sec)->this_hdr.contents = contents;
3362                     symtab_hdr->contents = (unsigned char *) isymbuf;
3363
3364                     /* Fix the opcode.  */
3365                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3366                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3367
3368                     /* Fix the relocation's type.  */
3369                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3370                                                  (ELF32_R_TYPE (irel->r_info)
3371                                                   == (int) R_MN10300_GOTOFF32)
3372                                                  ? R_MN10300_GOTOFF16
3373                                                  : (ELF32_R_TYPE (irel->r_info)
3374                                                     == (int) R_MN10300_GOT32)
3375                                                  ? R_MN10300_GOT16
3376                                                  : (ELF32_R_TYPE (irel->r_info)
3377                                                     == (int) R_MN10300_GOTPC32)
3378                                                  ? R_MN10300_GOTPC16 :
3379                                                  R_MN10300_16);
3380
3381                     /* Delete two bytes of data.  */
3382                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3383                                                          irel->r_offset + 2, 2))
3384                       goto error_return;
3385
3386                     /* That will change things, so, we should relax again.
3387                        Note that this is not required, and it may be slow.  */
3388                     *again = TRUE;
3389                     break;
3390                   }
3391               else if (code == 0xfe)
3392                 {
3393                   /* add imm32,sp -> add imm16,sp  */
3394
3395                   /* Note that we've changed the relocation contents, etc.  */
3396                   elf_section_data (sec)->relocs = internal_relocs;
3397                   elf_section_data (sec)->this_hdr.contents = contents;
3398                   symtab_hdr->contents = (unsigned char *) isymbuf;
3399
3400                   /* Fix the opcode.  */
3401                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3402                   bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
3403
3404                   /* Fix the relocation's type.  */
3405                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3406                                                (ELF32_R_TYPE (irel->r_info)
3407                                                 == (int) R_MN10300_GOT32)
3408                                                ? R_MN10300_GOT16
3409                                                : (ELF32_R_TYPE (irel->r_info)
3410                                                   == (int) R_MN10300_GOTOFF32)
3411                                                ? R_MN10300_GOTOFF16
3412                                                : (ELF32_R_TYPE (irel->r_info)
3413                                                   == (int) R_MN10300_GOTPC32)
3414                                                ? R_MN10300_GOTPC16 :
3415                                                R_MN10300_16);
3416
3417                   /* Delete two bytes of data.  */
3418                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3419                                                        irel->r_offset + 2, 2))
3420                     goto error_return;
3421
3422                   /* That will change things, so, we should relax again.
3423                      Note that this is not required, and it may be slow.  */
3424                   *again = TRUE;
3425                   break;
3426                 }
3427             }
3428         }
3429     }
3430
3431   if (isymbuf != NULL
3432       && symtab_hdr->contents != (unsigned char *) isymbuf)
3433     {
3434       if (! link_info->keep_memory)
3435         free (isymbuf);
3436       else
3437         {
3438           /* Cache the symbols for elf_link_input_bfd.  */
3439           symtab_hdr->contents = (unsigned char *) isymbuf;
3440         }
3441     }
3442
3443   if (contents != NULL
3444       && elf_section_data (sec)->this_hdr.contents != contents)
3445     {
3446       if (! link_info->keep_memory)
3447         free (contents);
3448       else
3449         {
3450           /* Cache the section contents for elf_link_input_bfd.  */
3451           elf_section_data (sec)->this_hdr.contents = contents;
3452         }
3453     }
3454
3455   if (internal_relocs != NULL
3456       && elf_section_data (sec)->relocs != internal_relocs)
3457     free (internal_relocs);
3458
3459   return TRUE;
3460
3461  error_return:
3462   if (isymbuf != NULL
3463       && symtab_hdr->contents != (unsigned char *) isymbuf)
3464     free (isymbuf);
3465   if (contents != NULL
3466       && elf_section_data (section)->this_hdr.contents != contents)
3467     free (contents);
3468   if (internal_relocs != NULL
3469       && elf_section_data (section)->relocs != internal_relocs)
3470     free (internal_relocs);
3471
3472   return FALSE;
3473 }
3474
3475 /* Compute the stack size and movm arguments for the function
3476    referred to by HASH at address ADDR in section with
3477    contents CONTENTS, store the information in the hash table.  */
3478 static void
3479 compute_function_info (abfd, hash, addr, contents)
3480      bfd *abfd;
3481      struct elf32_mn10300_link_hash_entry *hash;
3482      bfd_vma addr;
3483      unsigned char *contents;
3484 {
3485   unsigned char byte1, byte2;
3486   /* We only care about a very small subset of the possible prologue
3487      sequences here.  Basically we look for:
3488
3489      movm [d2,d3,a2,a3],sp (optional)
3490      add <size>,sp (optional, and only for sizes which fit in an unsigned
3491                     8 bit number)
3492
3493      If we find anything else, we quit.  */
3494
3495   /* Look for movm [regs],sp */
3496   byte1 = bfd_get_8 (abfd, contents + addr);
3497   byte2 = bfd_get_8 (abfd, contents + addr + 1);
3498
3499   if (byte1 == 0xcf)
3500     {
3501       hash->movm_args = byte2;
3502       addr += 2;
3503       byte1 = bfd_get_8 (abfd, contents + addr);
3504       byte2 = bfd_get_8 (abfd, contents + addr + 1);
3505     }
3506
3507   /* Now figure out how much stack space will be allocated by the movm
3508      instruction.  We need this kept separate from the funtion's normal
3509      stack space.  */
3510   if (hash->movm_args)
3511     {
3512       /* Space for d2.  */
3513       if (hash->movm_args & 0x80)
3514         hash->movm_stack_size += 4;
3515
3516       /* Space for d3.  */
3517       if (hash->movm_args & 0x40)
3518         hash->movm_stack_size += 4;
3519
3520       /* Space for a2.  */
3521       if (hash->movm_args & 0x20)
3522         hash->movm_stack_size += 4;
3523
3524       /* Space for a3.  */
3525       if (hash->movm_args & 0x10)
3526         hash->movm_stack_size += 4;
3527
3528       /* "other" space.  d0, d1, a0, a1, mdr, lir, lar, 4 byte pad.  */
3529       if (hash->movm_args & 0x08)
3530         hash->movm_stack_size += 8 * 4;
3531
3532       if (bfd_get_mach (abfd) == bfd_mach_am33
3533           || bfd_get_mach (abfd) == bfd_mach_am33_2)
3534         {
3535           /* "exother" space.  e0, e1, mdrq, mcrh, mcrl, mcvf */
3536           if (hash->movm_args & 0x1)
3537             hash->movm_stack_size += 6 * 4;
3538
3539           /* exreg1 space.  e4, e5, e6, e7 */
3540           if (hash->movm_args & 0x2)
3541             hash->movm_stack_size += 4 * 4;
3542
3543           /* exreg0 space.  e2, e3  */
3544           if (hash->movm_args & 0x4)
3545             hash->movm_stack_size += 2 * 4;
3546         }
3547     }
3548
3549   /* Now look for the two stack adjustment variants.  */
3550   if (byte1 == 0xf8 && byte2 == 0xfe)
3551     {
3552       int temp = bfd_get_8 (abfd, contents + addr + 2);
3553       temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
3554
3555       hash->stack_size = -temp;
3556     }
3557   else if (byte1 == 0xfa && byte2 == 0xfe)
3558     {
3559       int temp = bfd_get_16 (abfd, contents + addr + 2);
3560       temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
3561       temp = -temp;
3562
3563       if (temp < 255)
3564         hash->stack_size = temp;
3565     }
3566
3567   /* If the total stack to be allocated by the call instruction is more
3568      than 255 bytes, then we can't remove the stack adjustment by using
3569      "call" (we might still be able to remove the "movm" instruction.  */
3570   if (hash->stack_size + hash->movm_stack_size > 255)
3571     hash->stack_size = 0;
3572
3573   return;
3574 }
3575
3576 /* Delete some bytes from a section while relaxing.  */
3577
3578 static bfd_boolean
3579 mn10300_elf_relax_delete_bytes (abfd, sec, addr, count)
3580      bfd *abfd;
3581      asection *sec;
3582      bfd_vma addr;
3583      int count;
3584 {
3585   Elf_Internal_Shdr *symtab_hdr;
3586   unsigned int sec_shndx;
3587   bfd_byte *contents;
3588   Elf_Internal_Rela *irel, *irelend;
3589   Elf_Internal_Rela *irelalign;
3590   bfd_vma toaddr;
3591   Elf_Internal_Sym *isym, *isymend;
3592   struct elf_link_hash_entry **sym_hashes;
3593   struct elf_link_hash_entry **end_hashes;
3594   unsigned int symcount;
3595
3596   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
3597
3598   contents = elf_section_data (sec)->this_hdr.contents;
3599
3600   /* The deletion must stop at the next ALIGN reloc for an aligment
3601      power larger than the number of bytes we are deleting.  */
3602
3603   irelalign = NULL;
3604   toaddr = sec->_cooked_size;
3605
3606   irel = elf_section_data (sec)->relocs;
3607   irelend = irel + sec->reloc_count;
3608
3609   /* Actually delete the bytes.  */
3610   memmove (contents + addr, contents + addr + count,
3611            (size_t) (toaddr - addr - count));
3612   sec->_cooked_size -= count;
3613
3614   /* Adjust all the relocs.  */
3615   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
3616     {
3617       /* Get the new reloc address.  */
3618       if ((irel->r_offset > addr
3619            && irel->r_offset < toaddr))
3620         irel->r_offset -= count;
3621     }
3622
3623   /* Adjust the local symbols defined in this section.  */
3624   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3625   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
3626   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
3627     {
3628       if (isym->st_shndx == sec_shndx
3629           && isym->st_value > addr
3630           && isym->st_value < toaddr)
3631         isym->st_value -= count;
3632     }
3633
3634   /* Now adjust the global symbols defined in this section.  */
3635   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
3636               - symtab_hdr->sh_info);
3637   sym_hashes = elf_sym_hashes (abfd);
3638   end_hashes = sym_hashes + symcount;
3639   for (; sym_hashes < end_hashes; sym_hashes++)
3640     {
3641       struct elf_link_hash_entry *sym_hash = *sym_hashes;
3642       if ((sym_hash->root.type == bfd_link_hash_defined
3643            || sym_hash->root.type == bfd_link_hash_defweak)
3644           && sym_hash->root.u.def.section == sec
3645           && sym_hash->root.u.def.value > addr
3646           && sym_hash->root.u.def.value < toaddr)
3647         {
3648           sym_hash->root.u.def.value -= count;
3649         }
3650     }
3651
3652   return TRUE;
3653 }
3654
3655 /* Return TRUE if a symbol exists at the given address, else return
3656    FALSE.  */
3657 static bfd_boolean
3658 mn10300_elf_symbol_address_p (abfd, sec, isym, addr)
3659      bfd *abfd;
3660      asection *sec;
3661      Elf_Internal_Sym *isym;
3662      bfd_vma addr;
3663 {
3664   Elf_Internal_Shdr *symtab_hdr;
3665   unsigned int sec_shndx;
3666   Elf_Internal_Sym *isymend;
3667   struct elf_link_hash_entry **sym_hashes;
3668   struct elf_link_hash_entry **end_hashes;
3669   unsigned int symcount;
3670
3671   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
3672
3673   /* Examine all the symbols.  */
3674   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3675   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
3676     {
3677       if (isym->st_shndx == sec_shndx
3678           && isym->st_value == addr)
3679         return TRUE;
3680     }
3681
3682   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
3683               - symtab_hdr->sh_info);
3684   sym_hashes = elf_sym_hashes (abfd);
3685   end_hashes = sym_hashes + symcount;
3686   for (; sym_hashes < end_hashes; sym_hashes++)
3687     {
3688       struct elf_link_hash_entry *sym_hash = *sym_hashes;
3689       if ((sym_hash->root.type == bfd_link_hash_defined
3690            || sym_hash->root.type == bfd_link_hash_defweak)
3691           && sym_hash->root.u.def.section == sec
3692           && sym_hash->root.u.def.value == addr)
3693         return TRUE;
3694     }
3695
3696   return FALSE;
3697 }
3698
3699 /* This is a version of bfd_generic_get_relocated_section_contents
3700    which uses mn10300_elf_relocate_section.  */
3701
3702 static bfd_byte *
3703 mn10300_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
3704                                             data, relocatable, symbols)
3705      bfd *output_bfd;
3706      struct bfd_link_info *link_info;
3707      struct bfd_link_order *link_order;
3708      bfd_byte *data;
3709      bfd_boolean relocatable;
3710      asymbol **symbols;
3711 {
3712   Elf_Internal_Shdr *symtab_hdr;
3713   asection *input_section = link_order->u.indirect.section;
3714   bfd *input_bfd = input_section->owner;
3715   asection **sections = NULL;
3716   Elf_Internal_Rela *internal_relocs = NULL;
3717   Elf_Internal_Sym *isymbuf = NULL;
3718
3719   /* We only need to handle the case of relaxing, or of having a
3720      particular set of section contents, specially.  */
3721   if (relocatable
3722       || elf_section_data (input_section)->this_hdr.contents == NULL)
3723     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3724                                                        link_order, data,
3725                                                        relocatable,
3726                                                        symbols);
3727
3728   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3729
3730   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3731           (size_t) input_section->_raw_size);
3732
3733   if ((input_section->flags & SEC_RELOC) != 0
3734       && input_section->reloc_count > 0)
3735     {
3736       asection **secpp;
3737       Elf_Internal_Sym *isym, *isymend;
3738       bfd_size_type amt;
3739
3740       internal_relocs = (_bfd_elf_link_read_relocs
3741                          (input_bfd, input_section, (PTR) NULL,
3742                           (Elf_Internal_Rela *) NULL, FALSE));
3743       if (internal_relocs == NULL)
3744         goto error_return;
3745
3746       if (symtab_hdr->sh_info != 0)
3747         {
3748           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3749           if (isymbuf == NULL)
3750             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3751                                             symtab_hdr->sh_info, 0,
3752                                             NULL, NULL, NULL);
3753           if (isymbuf == NULL)
3754             goto error_return;
3755         }
3756
3757       amt = symtab_hdr->sh_info;
3758       amt *= sizeof (asection *);
3759       sections = (asection **) bfd_malloc (amt);
3760       if (sections == NULL && amt != 0)
3761         goto error_return;
3762
3763       isymend = isymbuf + symtab_hdr->sh_info;
3764       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3765         {
3766           asection *isec;
3767
3768           if (isym->st_shndx == SHN_UNDEF)
3769             isec = bfd_und_section_ptr;
3770           else if (isym->st_shndx == SHN_ABS)
3771             isec = bfd_abs_section_ptr;
3772           else if (isym->st_shndx == SHN_COMMON)
3773             isec = bfd_com_section_ptr;
3774           else
3775             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3776
3777           *secpp = isec;
3778         }
3779
3780       if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
3781                                      input_section, data, internal_relocs,
3782                                      isymbuf, sections))
3783         goto error_return;
3784
3785       if (sections != NULL)
3786         free (sections);
3787       if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3788         free (isymbuf);
3789       if (internal_relocs != elf_section_data (input_section)->relocs)
3790         free (internal_relocs);
3791     }
3792
3793   return data;
3794
3795  error_return:
3796   if (sections != NULL)
3797     free (sections);
3798   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3799     free (isymbuf);
3800   if (internal_relocs != NULL
3801       && internal_relocs != elf_section_data (input_section)->relocs)
3802     free (internal_relocs);
3803   return NULL;
3804 }
3805
3806 /* Assorted hash table functions.  */
3807
3808 /* Initialize an entry in the link hash table.  */
3809
3810 /* Create an entry in an MN10300 ELF linker hash table.  */
3811
3812 static struct bfd_hash_entry *
3813 elf32_mn10300_link_hash_newfunc (entry, table, string)
3814      struct bfd_hash_entry *entry;
3815      struct bfd_hash_table *table;
3816      const char *string;
3817 {
3818   struct elf32_mn10300_link_hash_entry *ret =
3819     (struct elf32_mn10300_link_hash_entry *) entry;
3820
3821   /* Allocate the structure if it has not already been allocated by a
3822      subclass.  */
3823   if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
3824     ret = ((struct elf32_mn10300_link_hash_entry *)
3825            bfd_hash_allocate (table,
3826                               sizeof (struct elf32_mn10300_link_hash_entry)));
3827   if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
3828     return (struct bfd_hash_entry *) ret;
3829
3830   /* Call the allocation method of the superclass.  */
3831   ret = ((struct elf32_mn10300_link_hash_entry *)
3832          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3833                                      table, string));
3834   if (ret != (struct elf32_mn10300_link_hash_entry *) NULL)
3835     {
3836       ret->direct_calls = 0;
3837       ret->stack_size = 0;
3838       ret->movm_args = 0;
3839       ret->movm_stack_size = 0;
3840       ret->pcrel_relocs_copied = NULL;
3841       ret->flags = 0;
3842     }
3843
3844   return (struct bfd_hash_entry *) ret;
3845 }
3846
3847 /* Create an mn10300 ELF linker hash table.  */
3848
3849 static struct bfd_link_hash_table *
3850 elf32_mn10300_link_hash_table_create (abfd)
3851      bfd *abfd;
3852 {
3853   struct elf32_mn10300_link_hash_table *ret;
3854   bfd_size_type amt = sizeof (struct elf32_mn10300_link_hash_table);
3855
3856   ret = (struct elf32_mn10300_link_hash_table *) bfd_malloc (amt);
3857   if (ret == (struct elf32_mn10300_link_hash_table *) NULL)
3858     return NULL;
3859
3860   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
3861                                        elf32_mn10300_link_hash_newfunc))
3862     {
3863       free (ret);
3864       return NULL;
3865     }
3866
3867   ret->flags = 0;
3868   amt = sizeof (struct elf_link_hash_table);
3869   ret->static_hash_table
3870     = (struct elf32_mn10300_link_hash_table *) bfd_malloc (amt);
3871   if (ret->static_hash_table == NULL)
3872     {
3873       free (ret);
3874       return NULL;
3875     }
3876
3877   if (! _bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
3878                                        elf32_mn10300_link_hash_newfunc))
3879     {
3880       free (ret->static_hash_table);
3881       free (ret);
3882       return NULL;
3883     }
3884   return &ret->root.root;
3885 }
3886
3887 /* Free an mn10300 ELF linker hash table.  */
3888
3889 static void
3890 elf32_mn10300_link_hash_table_free (hash)
3891      struct bfd_link_hash_table *hash;
3892 {
3893   struct elf32_mn10300_link_hash_table *ret
3894     = (struct elf32_mn10300_link_hash_table *) hash;
3895
3896   _bfd_generic_link_hash_table_free
3897     ((struct bfd_link_hash_table *) ret->static_hash_table);
3898   _bfd_generic_link_hash_table_free
3899     ((struct bfd_link_hash_table *) ret);
3900 }
3901
3902 static unsigned long
3903 elf_mn10300_mach (flags)
3904      flagword flags;
3905 {
3906   switch (flags & EF_MN10300_MACH)
3907     {
3908     case E_MN10300_MACH_MN10300:
3909     default:
3910       return bfd_mach_mn10300;
3911
3912     case E_MN10300_MACH_AM33:
3913       return bfd_mach_am33;
3914
3915     case E_MN10300_MACH_AM33_2:
3916       return bfd_mach_am33_2;
3917     }
3918 }
3919
3920 /* The final processing done just before writing out a MN10300 ELF object
3921    file.  This gets the MN10300 architecture right based on the machine
3922    number.  */
3923
3924 void
3925 _bfd_mn10300_elf_final_write_processing (abfd, linker)
3926      bfd *abfd;
3927      bfd_boolean linker ATTRIBUTE_UNUSED;
3928 {
3929   unsigned long val;
3930
3931   switch (bfd_get_mach (abfd))
3932     {
3933     default:
3934     case bfd_mach_mn10300:
3935       val = E_MN10300_MACH_MN10300;
3936       break;
3937
3938     case bfd_mach_am33:
3939       val = E_MN10300_MACH_AM33;
3940       break;
3941
3942     case bfd_mach_am33_2:
3943       val = E_MN10300_MACH_AM33_2;
3944       break;
3945     }
3946
3947   elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
3948   elf_elfheader (abfd)->e_flags |= val;
3949 }
3950
3951 bfd_boolean
3952 _bfd_mn10300_elf_object_p (abfd)
3953      bfd *abfd;
3954 {
3955   bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
3956                              elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
3957   return TRUE;
3958 }
3959
3960 /* Merge backend specific data from an object file to the output
3961    object file when linking.  */
3962
3963 bfd_boolean
3964 _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
3965      bfd *ibfd;
3966      bfd *obfd;
3967 {
3968   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3969       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3970     return TRUE;
3971
3972   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3973       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
3974     {
3975       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3976                                bfd_get_mach (ibfd)))
3977         return FALSE;
3978     }
3979
3980   return TRUE;
3981 }
3982
3983 #define PLT0_ENTRY_SIZE 15
3984 #define PLT_ENTRY_SIZE 20
3985 #define PIC_PLT_ENTRY_SIZE 24
3986
3987 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
3988 {
3989   0xfc, 0xa0, 0, 0, 0, 0,       /* mov  (.got+8),a0 */
3990   0xfe, 0xe, 0x10, 0, 0, 0, 0,  /* mov  (.got+4),r1 */
3991   0xf0, 0xf4,                   /* jmp  (a0) */
3992 };
3993
3994 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
3995 {
3996   0xfc, 0xa0, 0, 0, 0, 0,       /* mov  (nameN@GOT + .got),a0 */
3997   0xf0, 0xf4,                   /* jmp  (a0) */
3998   0xfe, 8, 0, 0, 0, 0, 0,       /* mov  reloc-table-address,r0 */
3999   0xdc, 0, 0, 0, 0,             /* jmp  .plt0 */
4000 };
4001
4002 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4003 {
4004   0xfc, 0x22, 0, 0, 0, 0,       /* mov  (nameN@GOT,a2),a0 */
4005   0xf0, 0xf4,                   /* jmp  (a0) */
4006   0xfe, 8, 0, 0, 0, 0, 0,       /* mov  reloc-table-address,r0 */
4007   0xf8, 0x22, 8,                /* mov  (8,a2),a0 */
4008   0xfb, 0xa, 0x1a, 4,           /* mov  (4,a2),r1 */
4009   0xf0, 0xf4,                   /* jmp  (a0) */
4010 };
4011
4012 /* Return size of the first PLT entry.  */
4013 #define elf_mn10300_sizeof_plt0(info) \
4014   (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4015
4016 /* Return size of a PLT entry.  */
4017 #define elf_mn10300_sizeof_plt(info) \
4018   (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4019
4020 /* Return offset of the PLT0 address in an absolute PLT entry.  */
4021 #define elf_mn10300_plt_plt0_offset(info) 16
4022
4023 /* Return offset of the linker in PLT0 entry.  */
4024 #define elf_mn10300_plt0_linker_offset(info) 2
4025
4026 /* Return offset of the GOT id in PLT0 entry.  */
4027 #define elf_mn10300_plt0_gotid_offset(info) 9
4028
4029 /* Return offset of the tempoline in PLT entry */
4030 #define elf_mn10300_plt_temp_offset(info) 8
4031
4032 /* Return offset of the symbol in PLT entry.  */
4033 #define elf_mn10300_plt_symbol_offset(info) 2
4034
4035 /* Return offset of the relocation in PLT entry.  */
4036 #define elf_mn10300_plt_reloc_offset(info) 11
4037
4038 /* The name of the dynamic interpreter.  This is put in the .interp
4039    section.  */
4040
4041 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4042
4043 /* Create dynamic sections when linking against a dynamic object.  */
4044
4045 static bfd_boolean
4046 _bfd_mn10300_elf_create_dynamic_sections (abfd, info)
4047      bfd *abfd;
4048      struct bfd_link_info *info;
4049 {
4050   flagword   flags;
4051   asection * s;
4052   struct elf_backend_data * bed = get_elf_backend_data (abfd);
4053   int ptralign = 0;
4054
4055   switch (bed->s->arch_size)
4056     {
4057     case 32:
4058       ptralign = 2;
4059       break;
4060
4061     case 64:
4062       ptralign = 3;
4063       break;
4064
4065     default:
4066       bfd_set_error (bfd_error_bad_value);
4067       return FALSE;
4068     }
4069
4070   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4071      .rel[a].bss sections.  */
4072
4073   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4074            | SEC_LINKER_CREATED);
4075
4076   s = bfd_make_section (abfd,
4077                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
4078   if (s == NULL
4079       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4080       || ! bfd_set_section_alignment (abfd, s, ptralign))
4081     return FALSE;
4082
4083   if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4084     return FALSE;
4085
4086   {
4087     const char * secname;
4088     char *       relname;
4089     flagword     secflags;
4090     asection *   sec;
4091
4092     for (sec = abfd->sections; sec; sec = sec->next)
4093       {
4094         secflags = bfd_get_section_flags (abfd, sec);
4095         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
4096             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
4097           continue;
4098
4099         secname = bfd_get_section_name (abfd, sec);
4100         relname = (char *) bfd_malloc (strlen (secname) + 6);
4101         strcpy (relname, ".rela");
4102         strcat (relname, secname);
4103
4104         s = bfd_make_section (abfd, relname);
4105         if (s == NULL
4106             || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4107             || ! bfd_set_section_alignment (abfd, s, ptralign))
4108           return FALSE;
4109       }
4110   }
4111
4112   if (bed->want_dynbss)
4113     {
4114       /* The .dynbss section is a place to put symbols which are defined
4115          by dynamic objects, are referenced by regular objects, and are
4116          not functions.  We must allocate space for them in the process
4117          image and use a R_*_COPY reloc to tell the dynamic linker to
4118          initialize them at run time.  The linker script puts the .dynbss
4119          section into the .bss section of the final image.  */
4120       s = bfd_make_section (abfd, ".dynbss");
4121       if (s == NULL
4122           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
4123         return FALSE;
4124
4125       /* The .rel[a].bss section holds copy relocs.  This section is not
4126          normally needed.  We need to create it here, though, so that the
4127          linker will map it to an output section.  We can't just create it
4128          only if we need it, because we will not know whether we need it
4129          until we have seen all the input files, and the first time the
4130          main linker code calls BFD after examining all the input files
4131          (size_dynamic_sections) the input sections have already been
4132          mapped to the output sections.  If the section turns out not to
4133          be needed, we can discard it later.  We will never need this
4134          section when generating a shared object, since they do not use
4135          copy relocs.  */
4136       if (! info->shared)
4137         {
4138           s = bfd_make_section (abfd,
4139                                 (bed->default_use_rela_p
4140                                  ? ".rela.bss" : ".rel.bss"));
4141           if (s == NULL
4142               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4143               || ! bfd_set_section_alignment (abfd, s, ptralign))
4144             return FALSE;
4145         }
4146     }
4147
4148   return TRUE;
4149 }
4150 \f
4151 /* Adjust a symbol defined by a dynamic object and referenced by a
4152    regular object.  The current definition is in some section of the
4153    dynamic object, but we're not including those sections.  We have to
4154    change the definition to something the rest of the link can
4155    understand.  */
4156
4157 static bfd_boolean
4158 _bfd_mn10300_elf_adjust_dynamic_symbol (info, h)
4159      struct bfd_link_info * info;
4160      struct elf_link_hash_entry * h;
4161 {
4162   bfd * dynobj;
4163   asection * s;
4164   unsigned int power_of_two;
4165
4166   dynobj = elf_hash_table (info)->dynobj;
4167
4168   /* Make sure we know what is going on here.  */
4169   BFD_ASSERT (dynobj != NULL
4170               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
4171                   || h->weakdef != NULL
4172                   || ((h->elf_link_hash_flags
4173                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4174                       && (h->elf_link_hash_flags
4175                           & ELF_LINK_HASH_REF_REGULAR) != 0
4176                       && (h->elf_link_hash_flags
4177                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
4178
4179   /* If this is a function, put it in the procedure linkage table.  We
4180      will fill in the contents of the procedure linkage table later,
4181      when we know the address of the .got section.  */
4182   if (h->type == STT_FUNC
4183       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
4184     {
4185       if (! info->shared
4186           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
4187           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
4188         {
4189           /* This case can occur if we saw a PLT reloc in an input
4190              file, but the symbol was never referred to by a dynamic
4191              object.  In such a case, we don't actually need to build
4192              a procedure linkage table, and we can just do a REL32
4193              reloc instead.  */
4194           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
4195           return TRUE;
4196         }
4197
4198       /* Make sure this symbol is output as a dynamic symbol.  */
4199       if (h->dynindx == -1)
4200         {
4201           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4202             return FALSE;
4203         }
4204
4205       s = bfd_get_section_by_name (dynobj, ".plt");
4206       BFD_ASSERT (s != NULL);
4207
4208       /* If this is the first .plt entry, make room for the special
4209          first entry.  */
4210       if (s->_raw_size == 0)
4211         s->_raw_size += elf_mn10300_sizeof_plt0 (info);
4212
4213       /* If this symbol is not defined in a regular file, and we are
4214          not generating a shared library, then set the symbol to this
4215          location in the .plt.  This is required to make function
4216          pointers compare as equal between the normal executable and
4217          the shared library.  */
4218       if (! info->shared
4219           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4220         {
4221           h->root.u.def.section = s;
4222           h->root.u.def.value = s->_raw_size;
4223         }
4224
4225       h->plt.offset = s->_raw_size;
4226
4227       /* Make room for this entry.  */
4228       s->_raw_size += elf_mn10300_sizeof_plt (info);
4229
4230       /* We also need to make an entry in the .got.plt section, which
4231          will be placed in the .got section by the linker script.  */
4232
4233       s = bfd_get_section_by_name (dynobj, ".got.plt");
4234       BFD_ASSERT (s != NULL);
4235       s->_raw_size += 4;
4236
4237       /* We also need to make an entry in the .rela.plt section.  */
4238
4239       s = bfd_get_section_by_name (dynobj, ".rela.plt");
4240       BFD_ASSERT (s != NULL);
4241       s->_raw_size += sizeof (Elf32_External_Rela);
4242
4243       return TRUE;
4244     }
4245
4246   /* If this is a weak symbol, and there is a real definition, the
4247      processor independent code will have arranged for us to see the
4248      real definition first, and we can just use the same value.  */
4249   if (h->weakdef != NULL)
4250     {
4251       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
4252                   || h->weakdef->root.type == bfd_link_hash_defweak);
4253       h->root.u.def.section = h->weakdef->root.u.def.section;
4254       h->root.u.def.value = h->weakdef->root.u.def.value;
4255       return TRUE;
4256     }
4257
4258   /* This is a reference to a symbol defined by a dynamic object which
4259      is not a function.  */
4260
4261   /* If we are creating a shared library, we must presume that the
4262      only references to the symbol are via the global offset table.
4263      For such cases we need not do anything here; the relocations will
4264      be handled correctly by relocate_section.  */
4265   if (info->shared)
4266     return TRUE;
4267
4268   /* If there are no references to this symbol that do not use the
4269      GOT, we don't need to generate a copy reloc.  */
4270   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
4271     return TRUE;
4272
4273   /* We must allocate the symbol in our .dynbss section, which will
4274      become part of the .bss section of the executable.  There will be
4275      an entry for this symbol in the .dynsym section.  The dynamic
4276      object will contain position independent code, so all references
4277      from the dynamic object to this symbol will go through the global
4278      offset table.  The dynamic linker will use the .dynsym entry to
4279      determine the address it must put in the global offset table, so
4280      both the dynamic object and the regular object will refer to the
4281      same memory location for the variable.  */
4282
4283   s = bfd_get_section_by_name (dynobj, ".dynbss");
4284   BFD_ASSERT (s != NULL);
4285
4286   /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4287      copy the initial value out of the dynamic object and into the
4288      runtime process image.  We need to remember the offset into the
4289      .rela.bss section we are going to use.  */
4290   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4291     {
4292       asection * srel;
4293
4294       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
4295       BFD_ASSERT (srel != NULL);
4296       srel->_raw_size += sizeof (Elf32_External_Rela);
4297       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
4298     }
4299
4300   /* We need to figure out the alignment required for this symbol.  I
4301      have no idea how ELF linkers handle this.  */
4302   power_of_two = bfd_log2 (h->size);
4303   if (power_of_two > 3)
4304     power_of_two = 3;
4305
4306   /* Apply the required alignment.  */
4307   s->_raw_size = BFD_ALIGN (s->_raw_size,
4308                             (bfd_size_type) (1 << power_of_two));
4309   if (power_of_two > bfd_get_section_alignment (dynobj, s))
4310     {
4311       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
4312         return FALSE;
4313     }
4314
4315   /* Define the symbol as being at this point in the section.  */
4316   h->root.u.def.section = s;
4317   h->root.u.def.value = s->_raw_size;
4318
4319   /* Increment the section size to make room for the symbol.  */
4320   s->_raw_size += h->size;
4321
4322   return TRUE;
4323 }
4324
4325 /* This function is called via elf32_mn10300_link_hash_traverse if we are
4326    creating a shared object with -Bsymbolic.  It discards the space
4327    allocated to copy PC relative relocs against symbols which are
4328    defined in regular objects.  We allocated space for them in the
4329    check_relocs routine, but we won't fill them in in the
4330    relocate_section routine.  */
4331
4332 static bfd_boolean
4333 _bfd_mn10300_elf_discard_copies (h, info)
4334      struct elf32_mn10300_link_hash_entry *h;
4335      struct bfd_link_info *info;
4336 {
4337   struct elf_mn10300_pcrel_relocs_copied *s;
4338
4339   /* If a symbol has been forced local or we have found a regular
4340      definition for the symbolic link case, then we won't be needing
4341      any relocs.  */
4342   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
4343       && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
4344           || info->symbolic))
4345     {
4346       for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
4347         s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
4348     }
4349
4350   return TRUE;
4351 }
4352
4353 /* Set the sizes of the dynamic sections.  */
4354
4355 static bfd_boolean
4356 _bfd_mn10300_elf_size_dynamic_sections (output_bfd, info)
4357      bfd * output_bfd;
4358      struct bfd_link_info * info;
4359 {
4360   bfd * dynobj;
4361   asection * s;
4362   bfd_boolean plt;
4363   bfd_boolean relocs;
4364   bfd_boolean reltext;
4365
4366   dynobj = elf_hash_table (info)->dynobj;
4367   BFD_ASSERT (dynobj != NULL);
4368
4369   if (elf_hash_table (info)->dynamic_sections_created)
4370     {
4371       /* Set the contents of the .interp section to the interpreter.  */
4372       if (! info->shared)
4373         {
4374           s = bfd_get_section_by_name (dynobj, ".interp");
4375           BFD_ASSERT (s != NULL);
4376           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
4377           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4378         }
4379     }
4380   else
4381     {
4382       /* We may have created entries in the .rela.got section.
4383          However, if we are not creating the dynamic sections, we will
4384          not actually use these entries.  Reset the size of .rela.got,
4385          which will cause it to get stripped from the output file
4386          below.  */
4387       s = bfd_get_section_by_name (dynobj, ".rela.got");
4388       if (s != NULL)
4389         s->_raw_size = 0;
4390     }
4391
4392   /* If this is a -Bsymbolic shared link, then we need to discard all
4393      PC relative relocs against symbols defined in a regular object.
4394      We allocated space for them in the check_relocs routine, but we
4395      will not fill them in in the relocate_section routine.  */
4396   if (info->shared && info->symbolic)
4397     elf32_mn10300_link_hash_traverse (elf32_mn10300_hash_table (info),
4398                                       _bfd_mn10300_elf_discard_copies,
4399                                       info);
4400
4401   /* The check_relocs and adjust_dynamic_symbol entry points have
4402      determined the sizes of the various dynamic sections.  Allocate
4403      memory for them.  */
4404   plt = FALSE;
4405   relocs = FALSE;
4406   reltext = FALSE;
4407   for (s = dynobj->sections; s != NULL; s = s->next)
4408     {
4409       const char * name;
4410       bfd_boolean strip;
4411
4412       if ((s->flags & SEC_LINKER_CREATED) == 0)
4413         continue;
4414
4415       /* It's OK to base decisions on the section name, because none
4416          of the dynobj section names depend upon the input files.  */
4417       name = bfd_get_section_name (dynobj, s);
4418
4419       strip = FALSE;
4420
4421       if (strcmp (name, ".plt") == 0)
4422         {
4423           if (s->_raw_size == 0)
4424             /* Strip this section if we don't need it; see the
4425                comment below.  */
4426             strip = TRUE;
4427           else
4428             /* Remember whether there is a PLT.  */
4429             plt = TRUE;
4430         }
4431       else if (strncmp (name, ".rela", 5) == 0)
4432         {
4433           if (s->_raw_size == 0)
4434             {
4435               /* If we don't need this section, strip it from the
4436                  output file.  This is mostly to handle .rela.bss and
4437                  .rela.plt.  We must create both sections in
4438                  create_dynamic_sections, because they must be created
4439                  before the linker maps input sections to output
4440                  sections.  The linker does that before
4441                  adjust_dynamic_symbol is called, and it is that
4442                  function which decides whether anything needs to go
4443                  into these sections.  */
4444               strip = TRUE;
4445             }
4446           else
4447             {
4448               asection * target;
4449
4450               /* Remember whether there are any reloc sections other
4451                  than .rela.plt.  */
4452               if (strcmp (name, ".rela.plt") != 0)
4453                 {
4454                   const char * outname;
4455
4456                   relocs = TRUE;
4457
4458                   /* If this relocation section applies to a read only
4459                      section, then we probably need a DT_TEXTREL
4460                      entry.  The entries in the .rela.plt section
4461                      really apply to the .got section, which we
4462                      created ourselves and so know is not readonly.  */
4463                   outname = bfd_get_section_name (output_bfd,
4464                                                   s->output_section);
4465                   target = bfd_get_section_by_name (output_bfd, outname + 5);
4466                   if (target != NULL
4467                       && (target->flags & SEC_READONLY) != 0
4468                       && (target->flags & SEC_ALLOC) != 0)
4469                     reltext = TRUE;
4470                 }
4471
4472               /* We use the reloc_count field as a counter if we need
4473                  to copy relocs into the output file.  */
4474               s->reloc_count = 0;
4475             }
4476         }
4477       else if (strncmp (name, ".got", 4) != 0)
4478         /* It's not one of our sections, so don't allocate space.  */
4479         continue;
4480
4481       if (strip)
4482         {
4483           _bfd_strip_section_from_output (info, s);
4484           continue;
4485         }
4486
4487       /* Allocate memory for the section contents.  We use bfd_zalloc
4488          here in case unused entries are not reclaimed before the
4489          section's contents are written out.  This should not happen,
4490          but this way if it does, we get a R_MN10300_NONE reloc
4491          instead of garbage.  */
4492       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
4493       if (s->contents == NULL && s->_raw_size != 0)
4494         return FALSE;
4495     }
4496
4497   if (elf_hash_table (info)->dynamic_sections_created)
4498     {
4499       /* Add some entries to the .dynamic section.  We fill in the
4500          values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4501          but we must add the entries now so that we get the correct
4502          size for the .dynamic section.  The DT_DEBUG entry is filled
4503          in by the dynamic linker and used by the debugger.  */
4504       if (! info->shared)
4505         {
4506           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
4507             return FALSE;
4508         }
4509
4510       if (plt)
4511         {
4512           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
4513               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4514               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
4515               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
4516             return FALSE;
4517         }
4518
4519       if (relocs)
4520         {
4521           if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
4522               || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
4523               || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
4524                                                 sizeof (Elf32_External_Rela)))
4525             return FALSE;
4526         }
4527
4528       if (reltext)
4529         {
4530           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
4531             return FALSE;
4532         }
4533     }
4534
4535   return TRUE;
4536 }
4537
4538 /* Finish up dynamic symbol handling.  We set the contents of various
4539    dynamic sections here.  */
4540
4541 static bfd_boolean
4542 _bfd_mn10300_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
4543      bfd * output_bfd;
4544      struct bfd_link_info * info;
4545      struct elf_link_hash_entry * h;
4546      Elf_Internal_Sym * sym;
4547 {
4548   bfd * dynobj;
4549
4550   dynobj = elf_hash_table (info)->dynobj;
4551
4552   if (h->plt.offset != (bfd_vma) -1)
4553     {
4554       asection *        splt;
4555       asection *        sgot;
4556       asection *        srel;
4557       bfd_vma           plt_index;
4558       bfd_vma           got_offset;
4559       Elf_Internal_Rela rel;
4560
4561       /* This symbol has an entry in the procedure linkage table.  Set
4562          it up.  */
4563
4564       BFD_ASSERT (h->dynindx != -1);
4565
4566       splt = bfd_get_section_by_name (dynobj, ".plt");
4567       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4568       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4569       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4570
4571       /* Get the index in the procedure linkage table which
4572          corresponds to this symbol.  This is the index of this symbol
4573          in all the symbols for which we are making plt entries.  The
4574          first entry in the procedure linkage table is reserved.  */
4575       plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
4576                    / elf_mn10300_sizeof_plt (info));
4577
4578       /* Get the offset into the .got table of the entry that
4579          corresponds to this function.  Each .got entry is 4 bytes.
4580          The first three are reserved.  */
4581       got_offset = (plt_index + 3) * 4;
4582
4583       /* Fill in the entry in the procedure linkage table.  */
4584       if (! info->shared)
4585         {
4586           memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
4587                   elf_mn10300_sizeof_plt (info));
4588           bfd_put_32 (output_bfd,
4589                       (sgot->output_section->vma
4590                        + sgot->output_offset
4591                        + got_offset),
4592                       (splt->contents + h->plt.offset
4593                        + elf_mn10300_plt_symbol_offset (info)));
4594
4595           bfd_put_32 (output_bfd,
4596                       (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
4597                       (splt->contents + h->plt.offset
4598                        + elf_mn10300_plt_plt0_offset (info)));
4599         }
4600       else
4601         {
4602           memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
4603                   elf_mn10300_sizeof_plt (info));
4604
4605           bfd_put_32 (output_bfd, got_offset,
4606                       (splt->contents + h->plt.offset
4607                        + elf_mn10300_plt_symbol_offset (info)));
4608         }
4609
4610       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4611                   (splt->contents + h->plt.offset
4612                    + elf_mn10300_plt_reloc_offset (info)));
4613
4614       /* Fill in the entry in the global offset table.  */
4615       bfd_put_32 (output_bfd,
4616                   (splt->output_section->vma
4617                    + splt->output_offset
4618                    + h->plt.offset
4619                    + elf_mn10300_plt_temp_offset (info)),
4620                   sgot->contents + got_offset);
4621
4622       /* Fill in the entry in the .rela.plt section.  */
4623       rel.r_offset = (sgot->output_section->vma
4624                       + sgot->output_offset
4625                       + got_offset);
4626       rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
4627       rel.r_addend = 0;
4628       bfd_elf32_swap_reloca_out (output_bfd, &rel,
4629                                 ((Elf32_External_Rela *) srel->contents
4630                                  + plt_index));
4631
4632       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4633         /* Mark the symbol as undefined, rather than as defined in
4634            the .plt section.  Leave the value alone.  */
4635         sym->st_shndx = SHN_UNDEF;
4636     }
4637
4638   if (h->got.offset != (bfd_vma) -1)
4639     {
4640       asection *        sgot;
4641       asection *        srel;
4642       Elf_Internal_Rela rel;
4643
4644       /* This symbol has an entry in the global offset table.  Set it up.  */
4645
4646       sgot = bfd_get_section_by_name (dynobj, ".got");
4647       srel = bfd_get_section_by_name (dynobj, ".rela.got");
4648       BFD_ASSERT (sgot != NULL && srel != NULL);
4649
4650       rel.r_offset = (sgot->output_section->vma
4651                       + sgot->output_offset
4652                       + (h->got.offset &~ 1));
4653
4654       /* If this is a -Bsymbolic link, and the symbol is defined
4655          locally, we just want to emit a RELATIVE reloc.  Likewise if
4656          the symbol was forced to be local because of a version file.
4657          The entry in the global offset table will already have been
4658          initialized in the relocate_section function.  */
4659       if (info->shared
4660           && (info->symbolic || h->dynindx == -1)
4661           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
4662         {
4663           rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
4664           rel.r_addend = (h->root.u.def.value
4665                           + h->root.u.def.section->output_section->vma
4666                           + h->root.u.def.section->output_offset);
4667         }
4668       else
4669         {
4670           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4671           rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
4672           rel.r_addend = 0;
4673         }
4674
4675       bfd_elf32_swap_reloca_out (output_bfd, &rel,
4676                                  ((Elf32_External_Rela *) srel->contents
4677                                   + srel->reloc_count));
4678       ++ srel->reloc_count;
4679     }
4680
4681   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4682     {
4683       asection *        s;
4684       Elf_Internal_Rela rel;
4685
4686       /* This symbol needs a copy reloc.  Set it up.  */
4687       BFD_ASSERT (h->dynindx != -1
4688                   && (h->root.type == bfd_link_hash_defined
4689                       || h->root.type == bfd_link_hash_defweak));
4690
4691       s = bfd_get_section_by_name (h->root.u.def.section->owner,
4692                                    ".rela.bss");
4693       BFD_ASSERT (s != NULL);
4694
4695       rel.r_offset = (h->root.u.def.value
4696                       + h->root.u.def.section->output_section->vma
4697                       + h->root.u.def.section->output_offset);
4698       rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
4699       rel.r_addend = 0;
4700       bfd_elf32_swap_reloca_out (output_bfd, &rel,
4701                                  ((Elf32_External_Rela *) s->contents
4702                                   + s->reloc_count));
4703       ++ s->reloc_count;
4704     }
4705
4706   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
4707   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4708       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
4709     sym->st_shndx = SHN_ABS;
4710
4711   return TRUE;
4712 }
4713
4714 /* Finish up the dynamic sections.  */
4715
4716 static bfd_boolean
4717 _bfd_mn10300_elf_finish_dynamic_sections (output_bfd, info)
4718      bfd * output_bfd;
4719      struct bfd_link_info * info;
4720 {
4721   bfd *      dynobj;
4722   asection * sgot;
4723   asection * sdyn;
4724
4725   dynobj = elf_hash_table (info)->dynobj;
4726
4727   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4728   BFD_ASSERT (sgot != NULL);
4729   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4730
4731   if (elf_hash_table (info)->dynamic_sections_created)
4732     {
4733       asection *           splt;
4734       Elf32_External_Dyn * dyncon;
4735       Elf32_External_Dyn * dynconend;
4736
4737       BFD_ASSERT (sdyn != NULL);
4738
4739       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4740       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4741
4742       for (; dyncon < dynconend; dyncon++)
4743         {
4744           Elf_Internal_Dyn dyn;
4745           const char * name;
4746           asection * s;
4747
4748           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4749
4750           switch (dyn.d_tag)
4751             {
4752             default:
4753               break;
4754
4755             case DT_PLTGOT:
4756               name = ".got";
4757               goto get_vma;
4758
4759             case DT_JMPREL:
4760               name = ".rela.plt";
4761             get_vma:
4762               s = bfd_get_section_by_name (output_bfd, name);
4763               BFD_ASSERT (s != NULL);
4764               dyn.d_un.d_ptr = s->vma;
4765               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4766               break;
4767
4768             case DT_PLTRELSZ:
4769               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4770               BFD_ASSERT (s != NULL);
4771               if (s->_cooked_size != 0)
4772                 dyn.d_un.d_val = s->_cooked_size;
4773               else
4774                 dyn.d_un.d_val = s->_raw_size;
4775               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4776               break;
4777
4778             case DT_RELASZ:
4779               /* My reading of the SVR4 ABI indicates that the
4780                  procedure linkage table relocs (DT_JMPREL) should be
4781                  included in the overall relocs (DT_RELA).  This is
4782                  what Solaris does.  However, UnixWare can not handle
4783                  that case.  Therefore, we override the DT_RELASZ entry
4784                  here to make it not include the JMPREL relocs.  Since
4785                  the linker script arranges for .rela.plt to follow all
4786                  other relocation sections, we don't have to worry
4787                  about changing the DT_RELA entry.  */
4788               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4789               if (s != NULL)
4790                 {
4791                   if (s->_cooked_size != 0)
4792                     dyn.d_un.d_val -= s->_cooked_size;
4793                   else
4794                     dyn.d_un.d_val -= s->_raw_size;
4795                 }
4796               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4797               break;
4798             }
4799         }
4800
4801       /* Fill in the first entry in the procedure linkage table.  */
4802       splt = bfd_get_section_by_name (dynobj, ".plt");
4803       if (splt && splt->_raw_size > 0)
4804         {
4805           if (info->shared)
4806             {
4807               memcpy (splt->contents, elf_mn10300_pic_plt_entry,
4808                       elf_mn10300_sizeof_plt (info));
4809             }
4810           else
4811             {
4812               memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
4813               bfd_put_32 (output_bfd,
4814                           sgot->output_section->vma + sgot->output_offset + 4,
4815                           splt->contents + elf_mn10300_plt0_gotid_offset (info));
4816               bfd_put_32 (output_bfd,
4817                           sgot->output_section->vma + sgot->output_offset + 8,
4818                           splt->contents + elf_mn10300_plt0_linker_offset (info));
4819             }
4820
4821           /* UnixWare sets the entsize of .plt to 4, although that doesn't
4822              really seem like the right value.  */
4823           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4824         }
4825     }
4826
4827   /* Fill in the first three entries in the global offset table.  */
4828   if (sgot->_raw_size > 0)
4829     {
4830       if (sdyn == NULL)
4831         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4832       else
4833         bfd_put_32 (output_bfd,
4834                     sdyn->output_section->vma + sdyn->output_offset,
4835                     sgot->contents);
4836       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4837       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4838     }
4839
4840   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4841
4842   return TRUE;
4843 }
4844
4845 #ifndef ELF_ARCH
4846 #define TARGET_LITTLE_SYM       bfd_elf32_mn10300_vec
4847 #define TARGET_LITTLE_NAME      "elf32-mn10300"
4848 #define ELF_ARCH                bfd_arch_mn10300
4849 #define ELF_MACHINE_CODE        EM_MN10300
4850 #define ELF_MACHINE_ALT1        EM_CYGNUS_MN10300
4851 #define ELF_MAXPAGESIZE         0x1000
4852 #endif
4853
4854 #define elf_info_to_howto               mn10300_info_to_howto
4855 #define elf_info_to_howto_rel           0
4856 #define elf_backend_can_gc_sections     1
4857 #define elf_backend_rela_normal         1
4858 #define elf_backend_check_relocs        mn10300_elf_check_relocs
4859 #define elf_backend_gc_mark_hook        mn10300_elf_gc_mark_hook
4860 #define elf_backend_relocate_section    mn10300_elf_relocate_section
4861 #define bfd_elf32_bfd_relax_section     mn10300_elf_relax_section
4862 #define bfd_elf32_bfd_get_relocated_section_contents \
4863                                 mn10300_elf_get_relocated_section_contents
4864 #define bfd_elf32_bfd_link_hash_table_create \
4865                                 elf32_mn10300_link_hash_table_create
4866 #define bfd_elf32_bfd_link_hash_table_free \
4867                                 elf32_mn10300_link_hash_table_free
4868
4869 #ifndef elf_symbol_leading_char
4870 #define elf_symbol_leading_char '_'
4871 #endif
4872
4873 /* So we can set bits in e_flags.  */
4874 #define elf_backend_final_write_processing \
4875                                         _bfd_mn10300_elf_final_write_processing
4876 #define elf_backend_object_p            _bfd_mn10300_elf_object_p
4877
4878 #define bfd_elf32_bfd_merge_private_bfd_data \
4879                                         _bfd_mn10300_elf_merge_private_bfd_data
4880
4881 #define elf_backend_can_gc_sections     1
4882 #define elf_backend_create_dynamic_sections \
4883   _bfd_mn10300_elf_create_dynamic_sections
4884 #define elf_backend_adjust_dynamic_symbol \
4885   _bfd_mn10300_elf_adjust_dynamic_symbol
4886 #define elf_backend_size_dynamic_sections \
4887   _bfd_mn10300_elf_size_dynamic_sections
4888 #define elf_backend_finish_dynamic_symbol \
4889   _bfd_mn10300_elf_finish_dynamic_symbol
4890 #define elf_backend_finish_dynamic_sections \
4891   _bfd_mn10300_elf_finish_dynamic_sections
4892
4893 #define elf_backend_want_got_plt        1
4894 #define elf_backend_plt_readonly        1
4895 #define elf_backend_want_plt_sym        0
4896 #define elf_backend_got_header_size     12
4897 #define elf_backend_plt_header_size     PLT0_ENTRY_SIZE
4898
4899 #include "elf32-target.h"