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