bfd/elf-m10300.c

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