bfd/elf-m10300.c

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