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