bfd/elf-m10300.c

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