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