bfd/elf-m10300.c

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