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