bfd/elf-m10300.c

   1 /* Matsushita 10300 specific support for 32-bit ELF
   2    Copyright (C) 1996-2016 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               (*info->callbacks->reloc_overflow)
2155                 (info, (h ? &h->root.root : NULL), name, howto->name,
2156                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2157               break;
2158
2159             case bfd_reloc_undefined:
2160               (*info->callbacks->undefined_symbol)
2161                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
2162               break;
2163
2164             case bfd_reloc_outofrange:
2165               msg = _("internal error: out of range error");
2166               goto common_error;
2167
2168             case bfd_reloc_notsupported:
2169               msg = _("internal error: unsupported relocation error");
2170               goto common_error;
2171
2172             case bfd_reloc_dangerous:
2173               if (r_type == R_MN10300_PCREL32)
2174                 msg = _("error: inappropriate relocation type for shared"
2175                         " library (did you forget -fpic?)");
2176               else if (r_type == R_MN10300_GOT32)
2177                 msg = _("%B: taking the address of protected function"
2178                         " '%s' cannot be done when making a shared library");
2179               else
2180                 msg = _("internal error: suspicious relocation type used"
2181                         " in shared library");
2182               goto common_error;
2183
2184             default:
2185               msg = _("internal error: unknown error");
2186               /* Fall through.  */
2187
2188             common_error:
2189               _bfd_error_handler (msg, input_bfd, name);
2190               bfd_set_error (bfd_error_bad_value);
2191               return FALSE;
2192             }
2193         }
2194     }
2195
2196   return TRUE;
2197 }
2198
2199 /* Finish initializing one hash table entry.  */
2200
2201 static bfd_boolean
2202 elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
2203                                        void * in_args)
2204 {
2205   struct elf32_mn10300_link_hash_entry *entry;
2206   struct bfd_link_info *link_info = (struct bfd_link_info *) in_args;
2207   unsigned int byte_count = 0;
2208
2209   entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
2210
2211   /* If we already know we want to convert "call" to "calls" for calls
2212      to this symbol, then return now.  */
2213   if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
2214     return TRUE;
2215
2216   /* If there are no named calls to this symbol, or there's nothing we
2217      can move from the function itself into the "call" instruction,
2218      then note that all "call" instructions should be converted into
2219      "calls" instructions and return.  If a symbol is available for
2220      dynamic symbol resolution (overridable or overriding), avoid
2221      custom calling conventions.  */
2222   if (entry->direct_calls == 0
2223       || (entry->stack_size == 0 && entry->movm_args == 0)
2224       || (elf_hash_table (link_info)->dynamic_sections_created
2225           && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL
2226           && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN))
2227     {
2228       /* Make a note that we should convert "call" instructions to "calls"
2229          instructions for calls to this symbol.  */
2230       entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2231       return TRUE;
2232     }
2233
2234   /* We may be able to move some instructions from the function itself into
2235      the "call" instruction.  Count how many bytes we might be able to
2236      eliminate in the function itself.  */
2237
2238   /* A movm instruction is two bytes.  */
2239   if (entry->movm_args)
2240     byte_count += 2;
2241
2242   /* Count the insn to allocate stack space too.  */
2243   if (entry->stack_size > 0)
2244     {
2245       if (entry->stack_size <= 128)
2246         byte_count += 3;
2247       else
2248         byte_count += 4;
2249     }
2250
2251   /* If using "call" will result in larger code, then turn all
2252      the associated "call" instructions into "calls" instructions.  */
2253   if (byte_count < entry->direct_calls)
2254     entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2255
2256   /* This routine never fails.  */
2257   return TRUE;
2258 }
2259
2260 /* Used to count hash table entries.  */
2261
2262 static bfd_boolean
2263 elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
2264                                         void * in_args)
2265 {
2266   int *count = (int *) in_args;
2267
2268   (*count) ++;
2269   return TRUE;
2270 }
2271
2272 /* Used to enumerate hash table entries into a linear array.  */
2273
2274 static bfd_boolean
2275 elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
2276                                        void * in_args)
2277 {
2278   struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args;
2279
2280   **ptr = gen_entry;
2281   (*ptr) ++;
2282   return TRUE;
2283 }
2284
2285 /* Used to sort the array created by the above.  */
2286
2287 static int
2288 sort_by_value (const void *va, const void *vb)
2289 {
2290   struct elf32_mn10300_link_hash_entry *a
2291     = *(struct elf32_mn10300_link_hash_entry **) va;
2292   struct elf32_mn10300_link_hash_entry *b
2293     = *(struct elf32_mn10300_link_hash_entry **) vb;
2294
2295   return a->value - b->value;
2296 }
2297
2298 /* Compute the stack size and movm arguments for the function
2299    referred to by HASH at address ADDR in section with
2300    contents CONTENTS, store the information in the hash table.  */
2301
2302 static void
2303 compute_function_info (bfd *abfd,
2304                        struct elf32_mn10300_link_hash_entry *hash,
2305                        bfd_vma addr,
2306                        unsigned char *contents)
2307 {
2308   unsigned char byte1, byte2;
2309   /* We only care about a very small subset of the possible prologue
2310      sequences here.  Basically we look for:
2311
2312      movm [d2,d3,a2,a3],sp (optional)
2313      add <size>,sp (optional, and only for sizes which fit in an unsigned
2314                     8 bit number)
2315
2316      If we find anything else, we quit.  */
2317
2318   /* Look for movm [regs],sp.  */
2319   byte1 = bfd_get_8 (abfd, contents + addr);
2320   byte2 = bfd_get_8 (abfd, contents + addr + 1);
2321
2322   if (byte1 == 0xcf)
2323     {
2324       hash->movm_args = byte2;
2325       addr += 2;
2326       byte1 = bfd_get_8 (abfd, contents + addr);
2327       byte2 = bfd_get_8 (abfd, contents + addr + 1);
2328     }
2329
2330   /* Now figure out how much stack space will be allocated by the movm
2331      instruction.  We need this kept separate from the function's normal
2332      stack space.  */
2333   if (hash->movm_args)
2334     {
2335       /* Space for d2.  */
2336       if (hash->movm_args & 0x80)
2337         hash->movm_stack_size += 4;
2338
2339       /* Space for d3.  */
2340       if (hash->movm_args & 0x40)
2341         hash->movm_stack_size += 4;
2342
2343       /* Space for a2.  */
2344       if (hash->movm_args & 0x20)
2345         hash->movm_stack_size += 4;
2346
2347       /* Space for a3.  */
2348       if (hash->movm_args & 0x10)
2349         hash->movm_stack_size += 4;
2350
2351       /* "other" space.  d0, d1, a0, a1, mdr, lir, lar, 4 byte pad.  */
2352       if (hash->movm_args & 0x08)
2353         hash->movm_stack_size += 8 * 4;
2354
2355       if (bfd_get_mach (abfd) == bfd_mach_am33
2356           || bfd_get_mach (abfd) == bfd_mach_am33_2)
2357         {
2358           /* "exother" space.  e0, e1, mdrq, mcrh, mcrl, mcvf */
2359           if (hash->movm_args & 0x1)
2360             hash->movm_stack_size += 6 * 4;
2361
2362           /* exreg1 space.  e4, e5, e6, e7 */
2363           if (hash->movm_args & 0x2)
2364             hash->movm_stack_size += 4 * 4;
2365
2366           /* exreg0 space.  e2, e3  */
2367           if (hash->movm_args & 0x4)
2368             hash->movm_stack_size += 2 * 4;
2369         }
2370     }
2371
2372   /* Now look for the two stack adjustment variants.  */
2373   if (byte1 == 0xf8 && byte2 == 0xfe)
2374     {
2375       int temp = bfd_get_8 (abfd, contents + addr + 2);
2376       temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2377
2378       hash->stack_size = -temp;
2379     }
2380   else if (byte1 == 0xfa && byte2 == 0xfe)
2381     {
2382       int temp = bfd_get_16 (abfd, contents + addr + 2);
2383       temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2384       temp = -temp;
2385
2386       if (temp < 255)
2387         hash->stack_size = temp;
2388     }
2389
2390   /* If the total stack to be allocated by the call instruction is more
2391      than 255 bytes, then we can't remove the stack adjustment by using
2392      "call" (we might still be able to remove the "movm" instruction.  */
2393   if (hash->stack_size + hash->movm_stack_size > 255)
2394     hash->stack_size = 0;
2395 }
2396
2397 /* Delete some bytes from a section while relaxing.  */
2398
2399 static bfd_boolean
2400 mn10300_elf_relax_delete_bytes (bfd *abfd,
2401                                 asection *sec,
2402                                 bfd_vma addr,
2403                                 int count)
2404 {
2405   Elf_Internal_Shdr *symtab_hdr;
2406   unsigned int sec_shndx;
2407   bfd_byte *contents;
2408   Elf_Internal_Rela *irel, *irelend;
2409   Elf_Internal_Rela *irelalign;
2410   bfd_vma toaddr;
2411   Elf_Internal_Sym *isym, *isymend;
2412   struct elf_link_hash_entry **sym_hashes;
2413   struct elf_link_hash_entry **end_hashes;
2414   unsigned int symcount;
2415
2416   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2417
2418   contents = elf_section_data (sec)->this_hdr.contents;
2419
2420   irelalign = NULL;
2421   toaddr = sec->size;
2422
2423   irel = elf_section_data (sec)->relocs;
2424   irelend = irel + sec->reloc_count;
2425
2426   if (sec->reloc_count > 0)
2427     {
2428       /* If there is an align reloc at the end of the section ignore it.
2429          GAS creates these relocs for reasons of its own, and they just
2430          serve to keep the section artifically inflated.  */
2431       if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN)
2432         --irelend;
2433
2434       /* The deletion must stop at the next ALIGN reloc for an aligment
2435          power larger than, or not a multiple of, the number of bytes we
2436          are deleting.  */
2437       for (; irel < irelend; irel++)
2438         {
2439           int alignment = 1 << irel->r_addend;
2440
2441           if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
2442               && irel->r_offset > addr
2443               && irel->r_offset < toaddr
2444               && (count < alignment
2445                   || alignment % count != 0))
2446             {
2447               irelalign = irel;
2448               toaddr = irel->r_offset;
2449               break;
2450             }
2451         }
2452     }
2453
2454   /* Actually delete the bytes.  */
2455   memmove (contents + addr, contents + addr + count,
2456            (size_t) (toaddr - addr - count));
2457
2458   /* Adjust the section's size if we are shrinking it, or else
2459      pad the bytes between the end of the shrunken region and
2460      the start of the next region with NOP codes.  */
2461   if (irelalign == NULL)
2462     {
2463       sec->size -= count;
2464       /* Include symbols at the end of the section, but
2465          not at the end of a sub-region of the section.  */
2466       toaddr ++;
2467     }
2468   else
2469     {
2470       int i;
2471
2472 #define NOP_OPCODE 0xcb
2473
2474       for (i = 0; i < count; i ++)
2475         bfd_put_8 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
2476     }
2477
2478   /* Adjust all the relocs.  */
2479   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2480     {
2481       /* Get the new reloc address.  */
2482       if ((irel->r_offset > addr
2483            && irel->r_offset < toaddr)
2484           || (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
2485               && irel->r_offset == toaddr))
2486         irel->r_offset -= count;
2487     }
2488
2489   /* Adjust the local symbols in the section, reducing their value
2490      by the number of bytes deleted.  Note - symbols within the deleted
2491      region are moved to the address of the start of the region, which
2492      actually means that they will address the byte beyond the end of
2493      the region once the deletion has been completed.  */
2494   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2495   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2496   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2497     {
2498       if (isym->st_shndx == sec_shndx
2499           && isym->st_value > addr
2500           && isym->st_value < toaddr)
2501         {
2502           if (isym->st_value < addr + count)
2503             isym->st_value = addr;
2504           else
2505             isym->st_value -= count;
2506         }
2507       /* Adjust the function symbol's size as well.  */
2508       else if (isym->st_shndx == sec_shndx
2509                && ELF_ST_TYPE (isym->st_info) == STT_FUNC
2510                && isym->st_value + isym->st_size > addr
2511                && isym->st_value + isym->st_size < toaddr)
2512         isym->st_size -= count;
2513     }
2514
2515   /* Now adjust the global symbols defined in this section.  */
2516   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2517               - symtab_hdr->sh_info);
2518   sym_hashes = elf_sym_hashes (abfd);
2519   end_hashes = sym_hashes + symcount;
2520   for (; sym_hashes < end_hashes; sym_hashes++)
2521     {
2522       struct elf_link_hash_entry *sym_hash = *sym_hashes;
2523
2524       if ((sym_hash->root.type == bfd_link_hash_defined
2525            || sym_hash->root.type == bfd_link_hash_defweak)
2526           && sym_hash->root.u.def.section == sec
2527           && sym_hash->root.u.def.value > addr
2528           && sym_hash->root.u.def.value < toaddr)
2529         {
2530           if (sym_hash->root.u.def.value < addr + count)
2531             sym_hash->root.u.def.value = addr;
2532           else
2533             sym_hash->root.u.def.value -= count;
2534         }
2535       /* Adjust the function symbol's size as well.  */
2536       else if (sym_hash->root.type == bfd_link_hash_defined
2537                && sym_hash->root.u.def.section == sec
2538                && sym_hash->type == STT_FUNC
2539                && sym_hash->root.u.def.value + sym_hash->size > addr
2540                && sym_hash->root.u.def.value + sym_hash->size < toaddr)
2541         sym_hash->size -= count;
2542     }
2543
2544   /* See if we can move the ALIGN reloc forward.
2545      We have adjusted r_offset for it already.  */
2546   if (irelalign != NULL)
2547     {
2548       bfd_vma alignto, alignaddr;
2549
2550       if ((int) irelalign->r_addend > 0)
2551         {
2552           /* This is the old address.  */
2553           alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
2554           /* This is where the align points to now.  */
2555           alignaddr = BFD_ALIGN (irelalign->r_offset,
2556                                  1 << irelalign->r_addend);
2557           if (alignaddr < alignto)
2558             /* Tail recursion.  */
2559             return mn10300_elf_relax_delete_bytes (abfd, sec, alignaddr,
2560                                                    (int) (alignto - alignaddr));
2561         }
2562     }
2563
2564   return TRUE;
2565 }
2566
2567 /* Return TRUE if a symbol exists at the given address, else return
2568    FALSE.  */
2569
2570 static bfd_boolean
2571 mn10300_elf_symbol_address_p (bfd *abfd,
2572                               asection *sec,
2573                               Elf_Internal_Sym *isym,
2574                               bfd_vma addr)
2575 {
2576   Elf_Internal_Shdr *symtab_hdr;
2577   unsigned int sec_shndx;
2578   Elf_Internal_Sym *isymend;
2579   struct elf_link_hash_entry **sym_hashes;
2580   struct elf_link_hash_entry **end_hashes;
2581   unsigned int symcount;
2582
2583   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2584
2585   /* Examine all the symbols.  */
2586   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2587   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2588     if (isym->st_shndx == sec_shndx
2589         && isym->st_value == addr)
2590       return TRUE;
2591
2592   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2593               - symtab_hdr->sh_info);
2594   sym_hashes = elf_sym_hashes (abfd);
2595   end_hashes = sym_hashes + symcount;
2596   for (; sym_hashes < end_hashes; sym_hashes++)
2597     {
2598       struct elf_link_hash_entry *sym_hash = *sym_hashes;
2599
2600       if ((sym_hash->root.type == bfd_link_hash_defined
2601            || sym_hash->root.type == bfd_link_hash_defweak)
2602           && sym_hash->root.u.def.section == sec
2603           && sym_hash->root.u.def.value == addr)
2604         return TRUE;
2605     }
2606
2607   return FALSE;
2608 }
2609
2610 /* This function handles relaxing for the mn10300.
2611
2612    There are quite a few relaxing opportunities available on the mn10300:
2613
2614         * calls:32 -> calls:16                                     2 bytes
2615         * call:32  -> call:16                                      2 bytes
2616
2617         * call:32 -> calls:32                                      1 byte
2618         * call:16 -> calls:16                                      1 byte
2619                 * These are done anytime using "calls" would result
2620                 in smaller code, or when necessary to preserve the
2621                 meaning of the program.
2622
2623         * call:32                                                  varies
2624         * call:16
2625                 * In some circumstances we can move instructions
2626                 from a function prologue into a "call" instruction.
2627                 This is only done if the resulting code is no larger
2628                 than the original code.
2629
2630         * jmp:32 -> jmp:16                                         2 bytes
2631         * jmp:16 -> bra:8                                          1 byte
2632
2633                 * If the previous instruction is a conditional branch
2634                 around the jump/bra, we may be able to reverse its condition
2635                 and change its target to the jump's target.  The jump/bra
2636                 can then be deleted.                               2 bytes
2637
2638         * mov abs32 -> mov abs16                                   1 or 2 bytes
2639
2640         * Most instructions which accept imm32 can relax to imm16  1 or 2 bytes
2641         - Most instructions which accept imm16 can relax to imm8   1 or 2 bytes
2642
2643         * Most instructions which accept d32 can relax to d16      1 or 2 bytes
2644         - Most instructions which accept d16 can relax to d8       1 or 2 bytes
2645
2646         We don't handle imm16->imm8 or d16->d8 as they're very rare
2647         and somewhat more difficult to support.  */
2648
2649 static bfd_boolean
2650 mn10300_elf_relax_section (bfd *abfd,
2651                            asection *sec,
2652                            struct bfd_link_info *link_info,
2653                            bfd_boolean *again)
2654 {
2655   Elf_Internal_Shdr *symtab_hdr;
2656   Elf_Internal_Rela *internal_relocs = NULL;
2657   Elf_Internal_Rela *irel, *irelend;
2658   bfd_byte *contents = NULL;
2659   Elf_Internal_Sym *isymbuf = NULL;
2660   struct elf32_mn10300_link_hash_table *hash_table;
2661   asection *section = sec;
2662   bfd_vma align_gap_adjustment;
2663
2664   if (bfd_link_relocatable (link_info))
2665     (*link_info->callbacks->einfo)
2666       (_("%P%F: --relax and -r may not be used together\n"));
2667
2668   /* Assume nothing changes.  */
2669   *again = FALSE;
2670
2671   /* We need a pointer to the mn10300 specific hash table.  */
2672   hash_table = elf32_mn10300_hash_table (link_info);
2673   if (hash_table == NULL)
2674     return FALSE;
2675
2676   /* Initialize fields in each hash table entry the first time through.  */
2677   if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
2678     {
2679       bfd *input_bfd;
2680
2681       /* Iterate over all the input bfds.  */
2682       for (input_bfd = link_info->input_bfds;
2683            input_bfd != NULL;
2684            input_bfd = input_bfd->link.next)
2685         {
2686           /* We're going to need all the symbols for each bfd.  */
2687           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2688           if (symtab_hdr->sh_info != 0)
2689             {
2690               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2691               if (isymbuf == NULL)
2692                 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2693                                                 symtab_hdr->sh_info, 0,
2694                                                 NULL, NULL, NULL);
2695               if (isymbuf == NULL)
2696                 goto error_return;
2697             }
2698
2699           /* Iterate over each section in this bfd.  */
2700           for (section = input_bfd->sections;
2701                section != NULL;
2702                section = section->next)
2703             {
2704               struct elf32_mn10300_link_hash_entry *hash;
2705               asection *sym_sec = NULL;
2706               const char *sym_name;
2707               char *new_name;
2708
2709               /* If there's nothing to do in this section, skip it.  */
2710               if (! ((section->flags & SEC_RELOC) != 0
2711                      && section->reloc_count != 0))
2712                 continue;
2713               if ((section->flags & SEC_ALLOC) == 0)
2714                 continue;
2715
2716               /* Get cached copy of section contents if it exists.  */
2717               if (elf_section_data (section)->this_hdr.contents != NULL)
2718                 contents = elf_section_data (section)->this_hdr.contents;
2719               else if (section->size != 0)
2720                 {
2721                   /* Go get them off disk.  */
2722                   if (!bfd_malloc_and_get_section (input_bfd, section,
2723                                                    &contents))
2724                     goto error_return;
2725                 }
2726               else
2727                 contents = NULL;
2728
2729               /* If there aren't any relocs, then there's nothing to do.  */
2730               if ((section->flags & SEC_RELOC) != 0
2731                   && section->reloc_count != 0)
2732                 {
2733                   /* Get a copy of the native relocations.  */
2734                   internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2735                                                                NULL, NULL,
2736                                                                link_info->keep_memory);
2737                   if (internal_relocs == NULL)
2738                     goto error_return;
2739
2740                   /* Now examine each relocation.  */
2741                   irel = internal_relocs;
2742                   irelend = irel + section->reloc_count;
2743                   for (; irel < irelend; irel++)
2744                     {
2745                       long r_type;
2746                       unsigned long r_index;
2747                       unsigned char code;
2748
2749                       r_type = ELF32_R_TYPE (irel->r_info);
2750                       r_index = ELF32_R_SYM (irel->r_info);
2751
2752                       if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
2753                         goto error_return;
2754
2755                       /* We need the name and hash table entry of the target
2756                          symbol!  */
2757                       hash = NULL;
2758                       sym_sec = NULL;
2759
2760                       if (r_index < symtab_hdr->sh_info)
2761                         {
2762                           /* A local symbol.  */
2763                           Elf_Internal_Sym *isym;
2764                           struct elf_link_hash_table *elftab;
2765                           bfd_size_type amt;
2766
2767                           isym = isymbuf + r_index;
2768                           if (isym->st_shndx == SHN_UNDEF)
2769                             sym_sec = bfd_und_section_ptr;
2770                           else if (isym->st_shndx == SHN_ABS)
2771                             sym_sec = bfd_abs_section_ptr;
2772                           else if (isym->st_shndx == SHN_COMMON)
2773                             sym_sec = bfd_com_section_ptr;
2774                           else
2775                             sym_sec
2776                               = bfd_section_from_elf_index (input_bfd,
2777                                                             isym->st_shndx);
2778
2779                           sym_name
2780                             = bfd_elf_string_from_elf_section (input_bfd,
2781                                                                (symtab_hdr
2782                                                                 ->sh_link),
2783                                                                isym->st_name);
2784
2785                           /* If it isn't a function, then we don't care
2786                              about it.  */
2787                           if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
2788                             continue;
2789
2790                           /* Tack on an ID so we can uniquely identify this
2791                              local symbol in the global hash table.  */
2792                           amt = strlen (sym_name) + 10;
2793                           new_name = bfd_malloc (amt);
2794                           if (new_name == NULL)
2795                             goto error_return;
2796
2797                           sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2798                           sym_name = new_name;
2799
2800                           elftab = &hash_table->static_hash_table->root;
2801                           hash = ((struct elf32_mn10300_link_hash_entry *)
2802                                   elf_link_hash_lookup (elftab, sym_name,
2803                                                         TRUE, TRUE, FALSE));
2804                           free (new_name);
2805                         }
2806                       else
2807                         {
2808                           r_index -= symtab_hdr->sh_info;
2809                           hash = (struct elf32_mn10300_link_hash_entry *)
2810                                    elf_sym_hashes (input_bfd)[r_index];
2811                         }
2812
2813                       sym_name = hash->root.root.root.string;
2814                       if ((section->flags & SEC_CODE) != 0)
2815                         {
2816                           /* If this is not a "call" instruction, then we
2817                              should convert "call" instructions to "calls"
2818                              instructions.  */
2819                           code = bfd_get_8 (input_bfd,
2820                                             contents + irel->r_offset - 1);
2821                           if (code != 0xdd && code != 0xcd)
2822                             hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2823                         }
2824
2825                       /* If this is a jump/call, then bump the
2826                          direct_calls counter.  Else force "call" to
2827                          "calls" conversions.  */
2828                       if (r_type == R_MN10300_PCREL32
2829                           || r_type == R_MN10300_PLT32
2830                           || r_type == R_MN10300_PLT16
2831                           || r_type == R_MN10300_PCREL16)
2832                         hash->direct_calls++;
2833                       else
2834                         hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2835                     }
2836                 }
2837
2838               /* Now look at the actual contents to get the stack size,
2839                  and a list of what registers were saved in the prologue
2840                  (ie movm_args).  */
2841               if ((section->flags & SEC_CODE) != 0)
2842                 {
2843                   Elf_Internal_Sym *isym, *isymend;
2844                   unsigned int sec_shndx;
2845                   struct elf_link_hash_entry **hashes;
2846                   struct elf_link_hash_entry **end_hashes;
2847                   unsigned int symcount;
2848
2849                   sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2850                                                                  section);
2851
2852                   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2853                               - symtab_hdr->sh_info);
2854                   hashes = elf_sym_hashes (input_bfd);
2855                   end_hashes = hashes + symcount;
2856
2857                   /* Look at each function defined in this section and
2858                      update info for that function.  */
2859                   isymend = isymbuf + symtab_hdr->sh_info;
2860                   for (isym = isymbuf; isym < isymend; isym++)
2861                     {
2862                       if (isym->st_shndx == sec_shndx
2863                           && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2864                         {
2865                           struct elf_link_hash_table *elftab;
2866                           bfd_size_type amt;
2867                           struct elf_link_hash_entry **lhashes = hashes;
2868
2869                           /* Skip a local symbol if it aliases a
2870                              global one.  */
2871                           for (; lhashes < end_hashes; lhashes++)
2872                             {
2873                               hash = (struct elf32_mn10300_link_hash_entry *) *lhashes;
2874                               if ((hash->root.root.type == bfd_link_hash_defined
2875                                    || hash->root.root.type == bfd_link_hash_defweak)
2876                                   && hash->root.root.u.def.section == section
2877                                   && hash->root.type == STT_FUNC
2878                                   && hash->root.root.u.def.value == isym->st_value)
2879                                 break;
2880                             }
2881                           if (lhashes != end_hashes)
2882                             continue;
2883
2884                           if (isym->st_shndx == SHN_UNDEF)
2885                             sym_sec = bfd_und_section_ptr;
2886                           else if (isym->st_shndx == SHN_ABS)
2887                             sym_sec = bfd_abs_section_ptr;
2888                           else if (isym->st_shndx == SHN_COMMON)
2889                             sym_sec = bfd_com_section_ptr;
2890                           else
2891                             sym_sec
2892                               = bfd_section_from_elf_index (input_bfd,
2893                                                             isym->st_shndx);
2894
2895                           sym_name = (bfd_elf_string_from_elf_section
2896                                       (input_bfd, symtab_hdr->sh_link,
2897                                        isym->st_name));
2898
2899                           /* Tack on an ID so we can uniquely identify this
2900                              local symbol in the global hash table.  */
2901                           amt = strlen (sym_name) + 10;
2902                           new_name = bfd_malloc (amt);
2903                           if (new_name == NULL)
2904                             goto error_return;
2905
2906                           sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2907                           sym_name = new_name;
2908
2909                           elftab = &hash_table->static_hash_table->root;
2910                           hash = ((struct elf32_mn10300_link_hash_entry *)
2911                                   elf_link_hash_lookup (elftab, sym_name,
2912                                                         TRUE, TRUE, FALSE));
2913                           free (new_name);
2914                           compute_function_info (input_bfd, hash,
2915                                                  isym->st_value, contents);
2916                           hash->value = isym->st_value;
2917                         }
2918                     }
2919
2920                   for (; hashes < end_hashes; hashes++)
2921                     {
2922                       hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2923                       if ((hash->root.root.type == bfd_link_hash_defined
2924                            || hash->root.root.type == bfd_link_hash_defweak)
2925                           && hash->root.root.u.def.section == section
2926                           && hash->root.type == STT_FUNC)
2927                         compute_function_info (input_bfd, hash,
2928                                                (hash)->root.root.u.def.value,
2929                                                contents);
2930                     }
2931                 }
2932
2933               /* Cache or free any memory we allocated for the relocs.  */
2934               if (internal_relocs != NULL
2935                   && elf_section_data (section)->relocs != internal_relocs)
2936                 free (internal_relocs);
2937               internal_relocs = NULL;
2938
2939               /* Cache or free any memory we allocated for the contents.  */
2940               if (contents != NULL
2941                   && elf_section_data (section)->this_hdr.contents != contents)
2942                 {
2943                   if (! link_info->keep_memory)
2944                     free (contents);
2945                   else
2946                     {
2947                       /* Cache the section contents for elf_link_input_bfd.  */
2948                       elf_section_data (section)->this_hdr.contents = contents;
2949                     }
2950                 }
2951               contents = NULL;
2952             }
2953
2954           /* Cache or free any memory we allocated for the symbols.  */
2955           if (isymbuf != NULL
2956               && symtab_hdr->contents != (unsigned char *) isymbuf)
2957             {
2958               if (! link_info->keep_memory)
2959                 free (isymbuf);
2960               else
2961                 {
2962                   /* Cache the symbols for elf_link_input_bfd.  */
2963                   symtab_hdr->contents = (unsigned char *) isymbuf;
2964                 }
2965             }
2966           isymbuf = NULL;
2967         }
2968
2969       /* Now iterate on each symbol in the hash table and perform
2970          the final initialization steps on each.  */
2971       elf32_mn10300_link_hash_traverse (hash_table,
2972                                         elf32_mn10300_finish_hash_table_entry,
2973                                         link_info);
2974       elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2975                                         elf32_mn10300_finish_hash_table_entry,
2976                                         link_info);
2977
2978       {
2979         /* This section of code collects all our local symbols, sorts
2980            them by value, and looks for multiple symbols referring to
2981            the same address.  For those symbols, the flags are merged.
2982            At this point, the only flag that can be set is
2983            MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2984            together.  */
2985         int static_count = 0, i;
2986         struct elf32_mn10300_link_hash_entry **entries;
2987         struct elf32_mn10300_link_hash_entry **ptr;
2988
2989         elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2990                                           elf32_mn10300_count_hash_table_entries,
2991                                           &static_count);
2992
2993         entries = bfd_malloc (static_count * sizeof (* ptr));
2994
2995         ptr = entries;
2996         elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2997                                           elf32_mn10300_list_hash_table_entries,
2998                                           & ptr);
2999
3000         qsort (entries, static_count, sizeof (entries[0]), sort_by_value);
3001
3002         for (i = 0; i < static_count - 1; i++)
3003           if (entries[i]->value && entries[i]->value == entries[i+1]->value)
3004             {
3005               int v = entries[i]->flags;
3006               int j;
3007
3008               for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++)
3009                 v |= entries[j]->flags;
3010
3011               for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++)
3012                 entries[j]->flags = v;
3013
3014               i = j - 1;
3015             }
3016       }
3017
3018       /* All entries in the hash table are fully initialized.  */
3019       hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
3020
3021       /* Now that everything has been initialized, go through each
3022          code section and delete any prologue insns which will be
3023          redundant because their operations will be performed by
3024          a "call" instruction.  */
3025       for (input_bfd = link_info->input_bfds;
3026            input_bfd != NULL;
3027            input_bfd = input_bfd->link.next)
3028         {
3029           /* We're going to need all the local symbols for each bfd.  */
3030           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3031           if (symtab_hdr->sh_info != 0)
3032             {
3033               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3034               if (isymbuf == NULL)
3035                 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3036                                                 symtab_hdr->sh_info, 0,
3037                                                 NULL, NULL, NULL);
3038               if (isymbuf == NULL)
3039                 goto error_return;
3040             }
3041
3042           /* Walk over each section in this bfd.  */
3043           for (section = input_bfd->sections;
3044                section != NULL;
3045                section = section->next)
3046             {
3047               unsigned int sec_shndx;
3048               Elf_Internal_Sym *isym, *isymend;
3049               struct elf_link_hash_entry **hashes;
3050               struct elf_link_hash_entry **end_hashes;
3051               unsigned int symcount;
3052
3053               /* Skip non-code sections and empty sections.  */
3054               if ((section->flags & SEC_CODE) == 0 || section->size == 0)
3055                 continue;
3056
3057               if (section->reloc_count != 0)
3058                 {
3059                   /* Get a copy of the native relocations.  */
3060                   internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
3061                                                                NULL, NULL,
3062                                                                link_info->keep_memory);
3063                   if (internal_relocs == NULL)
3064                     goto error_return;
3065                 }
3066
3067               /* Get cached copy of section contents if it exists.  */
3068               if (elf_section_data (section)->this_hdr.contents != NULL)
3069                 contents = elf_section_data (section)->this_hdr.contents;
3070               else
3071                 {
3072                   /* Go get them off disk.  */
3073                   if (!bfd_malloc_and_get_section (input_bfd, section,
3074                                                    &contents))
3075                     goto error_return;
3076                 }
3077
3078               sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
3079                                                              section);
3080
3081               /* Now look for any function in this section which needs
3082                  insns deleted from its prologue.  */
3083               isymend = isymbuf + symtab_hdr->sh_info;
3084               for (isym = isymbuf; isym < isymend; isym++)
3085                 {
3086                   struct elf32_mn10300_link_hash_entry *sym_hash;
3087                   asection *sym_sec = NULL;
3088                   const char *sym_name;
3089                   char *new_name;
3090                   struct elf_link_hash_table *elftab;
3091                   bfd_size_type amt;
3092
3093                   if (isym->st_shndx != sec_shndx)
3094                     continue;
3095
3096                   if (isym->st_shndx == SHN_UNDEF)
3097                     sym_sec = bfd_und_section_ptr;
3098                   else if (isym->st_shndx == SHN_ABS)
3099                     sym_sec = bfd_abs_section_ptr;
3100                   else if (isym->st_shndx == SHN_COMMON)
3101                     sym_sec = bfd_com_section_ptr;
3102                   else
3103                     sym_sec
3104                       = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3105
3106                   sym_name
3107                     = bfd_elf_string_from_elf_section (input_bfd,
3108                                                        symtab_hdr->sh_link,
3109                                                        isym->st_name);
3110
3111                   /* Tack on an ID so we can uniquely identify this
3112                      local symbol in the global hash table.  */
3113                   amt = strlen (sym_name) + 10;
3114                   new_name = bfd_malloc (amt);
3115                   if (new_name == NULL)
3116                     goto error_return;
3117                   sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
3118                   sym_name = new_name;
3119
3120                   elftab = & hash_table->static_hash_table->root;
3121                   sym_hash = (struct elf32_mn10300_link_hash_entry *)
3122                     elf_link_hash_lookup (elftab, sym_name,
3123                                           FALSE, FALSE, FALSE);
3124
3125                   free (new_name);
3126                   if (sym_hash == NULL)
3127                     continue;
3128
3129                   if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
3130                       && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
3131                     {
3132                       int bytes = 0;
3133
3134                       /* Note that we've changed things.  */
3135                       elf_section_data (section)->relocs = internal_relocs;
3136                       elf_section_data (section)->this_hdr.contents = contents;
3137                       symtab_hdr->contents = (unsigned char *) isymbuf;
3138
3139                       /* Count how many bytes we're going to delete.  */
3140                       if (sym_hash->movm_args)
3141                         bytes += 2;
3142
3143                       if (sym_hash->stack_size > 0)
3144                         {
3145                           if (sym_hash->stack_size <= 128)
3146                             bytes += 3;
3147                           else
3148                             bytes += 4;
3149                         }
3150
3151                       /* Note that we've deleted prologue bytes for this
3152                          function.  */
3153                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
3154
3155                       /* Actually delete the bytes.  */
3156                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
3157                                                            section,
3158                                                            isym->st_value,
3159                                                            bytes))
3160                         goto error_return;
3161
3162                       /* Something changed.  Not strictly necessary, but
3163                          may lead to more relaxing opportunities.  */
3164                       *again = TRUE;
3165                     }
3166                 }
3167
3168               /* Look for any global functions in this section which
3169                  need insns deleted from their prologues.  */
3170               symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
3171                           - symtab_hdr->sh_info);
3172               hashes = elf_sym_hashes (input_bfd);
3173               end_hashes = hashes + symcount;
3174               for (; hashes < end_hashes; hashes++)
3175                 {
3176                   struct elf32_mn10300_link_hash_entry *sym_hash;
3177
3178                   sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
3179                   if ((sym_hash->root.root.type == bfd_link_hash_defined
3180                        || sym_hash->root.root.type == bfd_link_hash_defweak)
3181                       && sym_hash->root.root.u.def.section == section
3182                       && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
3183                       && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
3184                     {
3185                       int bytes = 0;
3186                       bfd_vma symval;
3187                       struct elf_link_hash_entry **hh;
3188
3189                       /* Note that we've changed things.  */
3190                       elf_section_data (section)->relocs = internal_relocs;
3191                       elf_section_data (section)->this_hdr.contents = contents;
3192                       symtab_hdr->contents = (unsigned char *) isymbuf;
3193
3194                       /* Count how many bytes we're going to delete.  */
3195                       if (sym_hash->movm_args)
3196                         bytes += 2;
3197
3198                       if (sym_hash->stack_size > 0)
3199                         {
3200                           if (sym_hash->stack_size <= 128)
3201                             bytes += 3;
3202                           else
3203                             bytes += 4;
3204                         }
3205
3206                       /* Note that we've deleted prologue bytes for this
3207                          function.  */
3208                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
3209
3210                       /* Actually delete the bytes.  */
3211                       symval = sym_hash->root.root.u.def.value;
3212                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
3213                                                            section,
3214                                                            symval,
3215                                                            bytes))
3216                         goto error_return;
3217
3218                       /* There may be other C++ functions symbols with the same
3219                          address.  If so then mark these as having had their
3220                          prologue bytes deleted as well.  */
3221                       for (hh = elf_sym_hashes (input_bfd); hh < end_hashes; hh++)
3222                         {
3223                           struct elf32_mn10300_link_hash_entry *h;
3224
3225                           h = (struct elf32_mn10300_link_hash_entry *) * hh;
3226
3227                           if (h != sym_hash
3228                               && (h->root.root.type == bfd_link_hash_defined
3229                                   || h->root.root.type == bfd_link_hash_defweak)
3230                               && h->root.root.u.def.section == section
3231                               && ! (h->flags & MN10300_CONVERT_CALL_TO_CALLS)
3232                               && h->root.root.u.def.value == symval
3233                               && h->root.type == STT_FUNC)
3234                             h->flags |= MN10300_DELETED_PROLOGUE_BYTES;
3235                         }
3236
3237                       /* Something changed.  Not strictly necessary, but
3238                          may lead to more relaxing opportunities.  */
3239                       *again = TRUE;
3240                     }
3241                 }
3242
3243               /* Cache or free any memory we allocated for the relocs.  */
3244               if (internal_relocs != NULL
3245                   && elf_section_data (section)->relocs != internal_relocs)
3246                 free (internal_relocs);
3247               internal_relocs = NULL;
3248
3249               /* Cache or free any memory we allocated for the contents.  */
3250               if (contents != NULL
3251                   && elf_section_data (section)->this_hdr.contents != contents)
3252                 {
3253                   if (! link_info->keep_memory)
3254                     free (contents);
3255                   else
3256                     /* Cache the section contents for elf_link_input_bfd.  */
3257                     elf_section_data (section)->this_hdr.contents = contents;
3258                 }
3259               contents = NULL;
3260             }
3261
3262           /* Cache or free any memory we allocated for the symbols.  */
3263           if (isymbuf != NULL
3264               && symtab_hdr->contents != (unsigned char *) isymbuf)
3265             {
3266               if (! link_info->keep_memory)
3267                 free (isymbuf);
3268               else
3269                 /* Cache the symbols for elf_link_input_bfd.  */
3270                 symtab_hdr->contents = (unsigned char *) isymbuf;
3271             }
3272           isymbuf = NULL;
3273         }
3274     }
3275
3276   /* (Re)initialize for the basic instruction shortening/relaxing pass.  */
3277   contents = NULL;
3278   internal_relocs = NULL;
3279   isymbuf = NULL;
3280   /* For error_return.  */
3281   section = sec;
3282
3283   /* We don't have to do anything for a relocatable link, if
3284      this section does not have relocs, or if this is not a
3285      code section.  */
3286   if (bfd_link_relocatable (link_info)
3287       || (sec->flags & SEC_RELOC) == 0
3288       || sec->reloc_count == 0
3289       || (sec->flags & SEC_CODE) == 0)
3290     return TRUE;
3291
3292   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3293
3294   /* Get a copy of the native relocations.  */
3295   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
3296                                                link_info->keep_memory);
3297   if (internal_relocs == NULL)
3298     goto error_return;
3299
3300   /* Scan for worst case alignment gap changes.  Note that this logic
3301      is not ideal; what we should do is run this scan for every
3302      opcode/address range and adjust accordingly, but that's
3303      expensive.  Worst case is that for an alignment of N bytes, we
3304      move by 2*N-N-1 bytes, assuming we have aligns of 1, 2, 4, 8, etc
3305      all before it.  Plus, this still doesn't cover cross-section
3306      jumps with section alignment.  */
3307   irelend = internal_relocs + sec->reloc_count;
3308   align_gap_adjustment = 0;
3309   for (irel = internal_relocs; irel < irelend; irel++)
3310     {
3311       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN)
3312         {
3313           bfd_vma adj = 1 << irel->r_addend;
3314           bfd_vma aend = irel->r_offset;
3315
3316           aend = BFD_ALIGN (aend, 1 << irel->r_addend);
3317           adj = 2 * adj - adj - 1;
3318
3319           /* Record the biggest adjustmnet.  Skip any alignment at the
3320              end of our section.  */
3321           if (align_gap_adjustment < adj
3322               && aend < sec->output_section->vma + sec->output_offset + sec->size)
3323             align_gap_adjustment = adj;
3324         }
3325     }
3326
3327   /* Walk through them looking for relaxing opportunities.  */
3328   irelend = internal_relocs + sec->reloc_count;
3329   for (irel = internal_relocs; irel < irelend; irel++)
3330     {
3331       bfd_vma symval;
3332       bfd_signed_vma jump_offset;
3333       asection *sym_sec = NULL;
3334       struct elf32_mn10300_link_hash_entry *h = NULL;
3335
3336       /* If this isn't something that can be relaxed, then ignore
3337          this reloc.  */
3338       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
3339           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
3340           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
3341         continue;
3342
3343       /* Get the section contents if we haven't done so already.  */
3344       if (contents == NULL)
3345         {
3346           /* Get cached copy if it exists.  */
3347           if (elf_section_data (sec)->this_hdr.contents != NULL)
3348             contents = elf_section_data (sec)->this_hdr.contents;
3349           else
3350             {
3351               /* Go get them off disk.  */
3352               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3353                 goto error_return;
3354             }
3355         }
3356
3357       /* Read this BFD's symbols if we haven't done so already.  */
3358       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
3359         {
3360           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3361           if (isymbuf == NULL)
3362             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3363                                             symtab_hdr->sh_info, 0,
3364                                             NULL, NULL, NULL);
3365           if (isymbuf == NULL)
3366             goto error_return;
3367         }
3368
3369       /* Get the value of the symbol referred to by the reloc.  */
3370       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
3371         {
3372           Elf_Internal_Sym *isym;
3373           const char *sym_name;
3374           char *new_name;
3375
3376           /* A local symbol.  */
3377           isym = isymbuf + ELF32_R_SYM (irel->r_info);
3378           if (isym->st_shndx == SHN_UNDEF)
3379             sym_sec = bfd_und_section_ptr;
3380           else if (isym->st_shndx == SHN_ABS)
3381             sym_sec = bfd_abs_section_ptr;
3382           else if (isym->st_shndx == SHN_COMMON)
3383             sym_sec = bfd_com_section_ptr;
3384           else
3385             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3386
3387           sym_name = bfd_elf_string_from_elf_section (abfd,
3388                                                       symtab_hdr->sh_link,
3389                                                       isym->st_name);
3390
3391           if ((sym_sec->flags & SEC_MERGE)
3392               && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
3393             {
3394               symval = isym->st_value;
3395
3396               /* GAS may reduce relocations against symbols in SEC_MERGE
3397                  sections to a relocation against the section symbol when
3398                  the original addend was zero.  When the reloc is against
3399                  a section symbol we should include the addend in the
3400                  offset passed to _bfd_merged_section_offset, since the
3401                  location of interest is the original symbol.  On the
3402                  other hand, an access to "sym+addend" where "sym" is not
3403                  a section symbol should not include the addend;  Such an
3404                  access is presumed to be an offset from "sym";  The
3405                  location of interest is just "sym".  */
3406               if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
3407                 symval += irel->r_addend;
3408
3409               symval = _bfd_merged_section_offset (abfd, & sym_sec,
3410                                                    elf_section_data (sym_sec)->sec_info,
3411                                                    symval);
3412
3413               if (ELF_ST_TYPE (isym->st_info) != STT_SECTION)
3414                 symval += irel->r_addend;
3415
3416               symval += sym_sec->output_section->vma
3417                 + sym_sec->output_offset - irel->r_addend;
3418             }
3419           else
3420             symval = (isym->st_value
3421                       + sym_sec->output_section->vma
3422                       + sym_sec->output_offset);
3423
3424           /* Tack on an ID so we can uniquely identify this
3425              local symbol in the global hash table.  */
3426           new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
3427           if (new_name == NULL)
3428             goto error_return;
3429           sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
3430           sym_name = new_name;
3431
3432           h = (struct elf32_mn10300_link_hash_entry *)
3433                 elf_link_hash_lookup (&hash_table->static_hash_table->root,
3434                                       sym_name, FALSE, FALSE, FALSE);
3435           free (new_name);
3436         }
3437       else
3438         {
3439           unsigned long indx;
3440
3441           /* An external symbol.  */
3442           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
3443           h = (struct elf32_mn10300_link_hash_entry *)
3444                 (elf_sym_hashes (abfd)[indx]);
3445           BFD_ASSERT (h != NULL);
3446           if (h->root.root.type != bfd_link_hash_defined
3447               && h->root.root.type != bfd_link_hash_defweak)
3448             /* This appears to be a reference to an undefined
3449                symbol.  Just ignore it--it will be caught by the
3450                regular reloc processing.  */
3451             continue;
3452
3453           /* Check for a reference to a discarded symbol and ignore it.  */
3454           if (h->root.root.u.def.section->output_section == NULL)
3455             continue;
3456
3457           sym_sec = h->root.root.u.def.section->output_section;
3458
3459           symval = (h->root.root.u.def.value
3460                     + h->root.root.u.def.section->output_section->vma
3461                     + h->root.root.u.def.section->output_offset);
3462         }
3463
3464       /* For simplicity of coding, we are going to modify the section
3465          contents, the section relocs, and the BFD symbol table.  We
3466          must tell the rest of the code not to free up this
3467          information.  It would be possible to instead create a table
3468          of changes which have to be made, as is done in coff-mips.c;
3469          that would be more work, but would require less memory when
3470          the linker is run.  */
3471
3472       /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
3473          branch/call, also deal with "call" -> "calls" conversions and
3474          insertion of prologue data into "call" instructions.  */
3475       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
3476           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
3477         {
3478           bfd_vma value = symval;
3479
3480           if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
3481               && h != NULL
3482               && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
3483               && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
3484               && h->root.plt.offset != (bfd_vma) -1)
3485             {
3486               asection * splt;
3487
3488               splt = hash_table->root.splt;
3489               value = ((splt->output_section->vma
3490                         + splt->output_offset
3491                         + h->root.plt.offset)
3492                        - (sec->output_section->vma
3493                           + sec->output_offset
3494                           + irel->r_offset));
3495             }
3496
3497           /* If we've got a "call" instruction that needs to be turned
3498              into a "calls" instruction, do so now.  It saves a byte.  */
3499           if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3500             {
3501               unsigned char code;
3502
3503               /* Get the opcode.  */
3504               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3505
3506               /* Make sure we're working with a "call" instruction!  */
3507               if (code == 0xdd)
3508                 {
3509                   /* Note that we've changed the relocs, section contents,
3510                      etc.  */
3511                   elf_section_data (sec)->relocs = internal_relocs;
3512                   elf_section_data (sec)->this_hdr.contents = contents;
3513                   symtab_hdr->contents = (unsigned char *) isymbuf;
3514
3515                   /* Fix the opcode.  */
3516                   bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
3517                   bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3518
3519                   /* Fix irel->r_offset and irel->r_addend.  */
3520                   irel->r_offset += 1;
3521                   irel->r_addend += 1;
3522
3523                   /* Delete one byte of data.  */
3524                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3525                                                        irel->r_offset + 3, 1))
3526                     goto error_return;
3527
3528                   /* That will change things, so, we should relax again.
3529                      Note that this is not required, and it may be slow.  */
3530                   *again = TRUE;
3531                 }
3532             }
3533           else if (h)
3534             {
3535               /* We've got a "call" instruction which needs some data
3536                  from target function filled in.  */
3537               unsigned char code;
3538
3539               /* Get the opcode.  */
3540               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3541
3542               /* Insert data from the target function into the "call"
3543                  instruction if needed.  */
3544               if (code == 0xdd)
3545                 {
3546                   bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
3547                   bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3548                              contents + irel->r_offset + 5);
3549                 }
3550             }
3551
3552           /* Deal with pc-relative gunk.  */
3553           value -= (sec->output_section->vma + sec->output_offset);
3554           value -= irel->r_offset;
3555           value += irel->r_addend;
3556
3557           /* See if the value will fit in 16 bits, note the high value is
3558              0x7fff + 2 as the target will be two bytes closer if we are
3559              able to relax, if it's in the same section.  */
3560           if (sec->output_section == sym_sec->output_section)
3561             jump_offset = 0x8001;
3562           else
3563             jump_offset = 0x7fff;
3564
3565           /* Account for jumps across alignment boundaries using
3566              align_gap_adjustment.  */
3567           if ((bfd_signed_vma) value < jump_offset - (bfd_signed_vma) align_gap_adjustment
3568               && ((bfd_signed_vma) value > -0x8000 + (bfd_signed_vma) align_gap_adjustment))
3569             {
3570               unsigned char code;
3571
3572               /* Get the opcode.  */
3573               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3574
3575               if (code != 0xdc && code != 0xdd && code != 0xff)
3576                 continue;
3577
3578               /* Note that we've changed the relocs, section contents, etc.  */
3579               elf_section_data (sec)->relocs = internal_relocs;
3580               elf_section_data (sec)->this_hdr.contents = contents;
3581               symtab_hdr->contents = (unsigned char *) isymbuf;
3582
3583               /* Fix the opcode.  */
3584               if (code == 0xdc)
3585                 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
3586               else if (code == 0xdd)
3587                 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
3588               else if (code == 0xff)
3589                 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3590
3591               /* Fix the relocation's type.  */
3592               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3593                                            (ELF32_R_TYPE (irel->r_info)
3594                                             == (int) R_MN10300_PLT32)
3595                                            ? R_MN10300_PLT16 :
3596                                            R_MN10300_PCREL16);
3597
3598               /* Delete two bytes of data.  */
3599               if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3600                                                    irel->r_offset + 1, 2))
3601                 goto error_return;
3602
3603               /* That will change things, so, we should relax again.
3604                  Note that this is not required, and it may be slow.  */
3605               *again = TRUE;
3606             }
3607         }
3608
3609       /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
3610          branch.  */
3611       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
3612         {
3613           bfd_vma value = symval;
3614
3615           /* If we've got a "call" instruction that needs to be turned
3616              into a "calls" instruction, do so now.  It saves a byte.  */
3617           if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3618             {
3619               unsigned char code;
3620
3621               /* Get the opcode.  */
3622               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3623
3624               /* Make sure we're working with a "call" instruction!  */
3625               if (code == 0xcd)
3626                 {
3627                   /* Note that we've changed the relocs, section contents,
3628                      etc.  */
3629                   elf_section_data (sec)->relocs = internal_relocs;
3630                   elf_section_data (sec)->this_hdr.contents = contents;
3631                   symtab_hdr->contents = (unsigned char *) isymbuf;
3632
3633                   /* Fix the opcode.  */
3634                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
3635                   bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3636
3637                   /* Fix irel->r_offset and irel->r_addend.  */
3638                   irel->r_offset += 1;
3639                   irel->r_addend += 1;
3640
3641                   /* Delete one byte of data.  */
3642                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3643                                                        irel->r_offset + 1, 1))
3644                     goto error_return;
3645
3646                   /* That will change things, so, we should relax again.
3647                      Note that this is not required, and it may be slow.  */
3648                   *again = TRUE;
3649                 }
3650             }
3651           else if (h)
3652             {
3653               unsigned char code;
3654
3655               /* Get the opcode.  */
3656               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3657
3658               /* Insert data from the target function into the "call"
3659                  instruction if needed.  */
3660               if (code == 0xcd)
3661                 {
3662                   bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
3663                   bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3664                              contents + irel->r_offset + 3);
3665                 }
3666             }
3667
3668           /* Deal with pc-relative gunk.  */
3669           value -= (sec->output_section->vma + sec->output_offset);
3670           value -= irel->r_offset;
3671           value += irel->r_addend;
3672
3673           /* See if the value will fit in 8 bits, note the high value is
3674              0x7f + 1 as the target will be one bytes closer if we are
3675              able to relax.  */
3676           if ((long) value < 0x80 && (long) value > -0x80)
3677             {
3678               unsigned char code;
3679
3680               /* Get the opcode.  */
3681               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3682
3683               if (code != 0xcc)
3684                 continue;
3685
3686               /* Note that we've changed the relocs, section contents, etc.  */
3687               elf_section_data (sec)->relocs = internal_relocs;
3688               elf_section_data (sec)->this_hdr.contents = contents;
3689               symtab_hdr->contents = (unsigned char *) isymbuf;
3690
3691               /* Fix the opcode.  */
3692               bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
3693
3694               /* Fix the relocation's type.  */
3695               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3696                                            R_MN10300_PCREL8);
3697
3698               /* Delete one byte of data.  */
3699               if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3700                                                    irel->r_offset + 1, 1))
3701                 goto error_return;
3702
3703               /* That will change things, so, we should relax again.
3704                  Note that this is not required, and it may be slow.  */
3705               *again = TRUE;
3706             }
3707         }
3708
3709       /* Try to eliminate an unconditional 8 bit pc-relative branch
3710          which immediately follows a conditional 8 bit pc-relative
3711          branch around the unconditional branch.
3712
3713             original:           new:
3714             bCC lab1            bCC' lab2
3715             bra lab2
3716            lab1:               lab1:
3717
3718          This happens when the bCC can't reach lab2 at assembly time,
3719          but due to other relaxations it can reach at link time.  */
3720       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
3721         {
3722           Elf_Internal_Rela *nrel;
3723           bfd_vma value = symval;
3724           unsigned char code;
3725
3726           /* Deal with pc-relative gunk.  */
3727           value -= (sec->output_section->vma + sec->output_offset);
3728           value -= irel->r_offset;
3729           value += irel->r_addend;
3730
3731           /* Do nothing if this reloc is the last byte in the section.  */
3732           if (irel->r_offset == sec->size)
3733             continue;
3734
3735           /* See if the next instruction is an unconditional pc-relative
3736              branch, more often than not this test will fail, so we
3737              test it first to speed things up.  */
3738           code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
3739           if (code != 0xca)
3740             continue;
3741
3742           /* Also make sure the next relocation applies to the next
3743              instruction and that it's a pc-relative 8 bit branch.  */
3744           nrel = irel + 1;
3745           if (nrel == irelend
3746               || irel->r_offset + 2 != nrel->r_offset
3747               || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3748             continue;
3749
3750           /* Make sure our destination immediately follows the
3751              unconditional branch.  */
3752           if (symval != (sec->output_section->vma + sec->output_offset
3753                          + irel->r_offset + 3))
3754             continue;
3755
3756           /* Now make sure we are a conditional branch.  This may not
3757              be necessary, but why take the chance.
3758
3759              Note these checks assume that R_MN10300_PCREL8 relocs
3760              only occur on bCC and bCCx insns.  If they occured
3761              elsewhere, we'd need to know the start of this insn
3762              for this check to be accurate.  */
3763           code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3764           if (code != 0xc0 && code != 0xc1 && code != 0xc2
3765               && code != 0xc3 && code != 0xc4 && code != 0xc5
3766               && code != 0xc6 && code != 0xc7 && code != 0xc8
3767               && code != 0xc9 && code != 0xe8 && code != 0xe9
3768               && code != 0xea && code != 0xeb)
3769             continue;
3770
3771           /* We also have to be sure there is no symbol/label
3772              at the unconditional branch.  */
3773           if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3774                                             irel->r_offset + 1))
3775             continue;
3776
3777           /* Note that we've changed the relocs, section contents, etc.  */
3778           elf_section_data (sec)->relocs = internal_relocs;
3779           elf_section_data (sec)->this_hdr.contents = contents;
3780           symtab_hdr->contents = (unsigned char *) isymbuf;
3781
3782           /* Reverse the condition of the first branch.  */
3783           switch (code)
3784             {
3785             case 0xc8:
3786               code = 0xc9;
3787               break;
3788             case 0xc9:
3789               code = 0xc8;
3790               break;
3791             case 0xc0:
3792               code = 0xc2;
3793               break;
3794             case 0xc2:
3795               code = 0xc0;
3796               break;
3797             case 0xc3:
3798               code = 0xc1;
3799               break;
3800             case 0xc1:
3801               code = 0xc3;
3802               break;
3803             case 0xc4:
3804               code = 0xc6;
3805               break;
3806             case 0xc6:
3807               code = 0xc4;
3808               break;
3809             case 0xc7:
3810               code = 0xc5;
3811               break;
3812             case 0xc5:
3813               code = 0xc7;
3814               break;
3815             case 0xe8:
3816               code = 0xe9;
3817               break;
3818             case 0x9d:
3819               code = 0xe8;
3820               break;
3821             case 0xea:
3822               code = 0xeb;
3823               break;
3824             case 0xeb:
3825               code = 0xea;
3826               break;
3827             }
3828           bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3829
3830           /* Set the reloc type and symbol for the first branch
3831              from the second branch.  */
3832           irel->r_info = nrel->r_info;
3833
3834           /* Make the reloc for the second branch a null reloc.  */
3835           nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3836                                        R_MN10300_NONE);
3837
3838           /* Delete two bytes of data.  */
3839           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3840                                                irel->r_offset + 1, 2))
3841             goto error_return;
3842
3843           /* That will change things, so, we should relax again.
3844              Note that this is not required, and it may be slow.  */
3845           *again = TRUE;
3846         }
3847
3848       /* Try to turn a 24 immediate, displacement or absolute address
3849          into a 8 immediate, displacement or absolute address.  */
3850       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3851         {
3852           bfd_vma value = symval;
3853           value += irel->r_addend;
3854
3855           /* See if the value will fit in 8 bits.  */
3856           if ((long) value < 0x7f && (long) value > -0x80)
3857             {
3858               unsigned char code;
3859
3860               /* AM33 insns which have 24 operands are 6 bytes long and
3861                  will have 0xfd as the first byte.  */
3862
3863               /* Get the first opcode.  */
3864               code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3865
3866               if (code == 0xfd)
3867                 {
3868                   /* Get the second opcode.  */
3869                   code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3870
3871                   /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3872                      equivalent instructions exists.  */
3873                   if (code != 0x6b && code != 0x7b
3874                       && code != 0x8b && code != 0x9b
3875                       && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3876                           || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3877                           || (code & 0x0f) == 0x0e))
3878                     {
3879                       /* Not safe if the high bit is on as relaxing may
3880                          move the value out of high mem and thus not fit
3881                          in a signed 8bit value.  This is currently over
3882                          conservative.  */
3883                       if ((value & 0x80) == 0)
3884                         {
3885                           /* Note that we've changed the relocation contents,
3886                              etc.  */
3887                           elf_section_data (sec)->relocs = internal_relocs;
3888                           elf_section_data (sec)->this_hdr.contents = contents;
3889                           symtab_hdr->contents = (unsigned char *) isymbuf;
3890
3891                           /* Fix the opcode.  */
3892                           bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3893                           bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3894
3895                           /* Fix the relocation's type.  */
3896                           irel->r_info =
3897                             ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3898                                           R_MN10300_8);
3899
3900                           /* Delete two bytes of data.  */
3901                           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3902                                                                irel->r_offset + 1, 2))
3903                             goto error_return;
3904
3905                           /* That will change things, so, we should relax
3906                              again.  Note that this is not required, and it
3907                              may be slow.  */
3908                           *again = TRUE;
3909                           break;
3910                         }
3911                     }
3912                 }
3913             }
3914         }
3915
3916       /* Try to turn a 32bit immediate, displacement or absolute address
3917          into a 16bit immediate, displacement or absolute address.  */
3918       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3919           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3920           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3921         {
3922           bfd_vma value = symval;
3923
3924           if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3925             {
3926               asection * sgot;
3927
3928               sgot = hash_table->root.sgot;
3929               if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3930                 {
3931                   value = sgot->output_offset;
3932
3933                   if (h)
3934                     value += h->root.got.offset;
3935                   else
3936                     value += (elf_local_got_offsets
3937                               (abfd)[ELF32_R_SYM (irel->r_info)]);
3938                 }
3939               else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3940                 value -= sgot->output_section->vma;
3941               else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3942                 value = (sgot->output_section->vma
3943                          - (sec->output_section->vma
3944                             + sec->output_offset
3945                             + irel->r_offset));
3946               else
3947                 abort ();
3948             }
3949
3950           value += irel->r_addend;
3951
3952           /* See if the value will fit in 24 bits.
3953              We allow any 16bit match here.  We prune those we can't
3954              handle below.  */
3955           if ((long) value < 0x7fffff && (long) value > -0x800000)
3956             {
3957               unsigned char code;
3958
3959               /* AM33 insns which have 32bit operands are 7 bytes long and
3960                  will have 0xfe as the first byte.  */
3961
3962               /* Get the first opcode.  */
3963               code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3964
3965               if (code == 0xfe)
3966                 {
3967                   /* Get the second opcode.  */
3968                   code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3969
3970                   /* All the am33 32 -> 24 relaxing possibilities.  */
3971                   /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3972                      equivalent instructions exists.  */
3973                   if (code != 0x6b && code != 0x7b
3974                       && code != 0x8b && code != 0x9b
3975                       && (ELF32_R_TYPE (irel->r_info)
3976                           != (int) R_MN10300_GOTPC32)
3977                       && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3978                           || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3979                           || (code & 0x0f) == 0x0e))
3980                     {
3981                       /* Not safe if the high bit is on as relaxing may
3982                          move the value out of high mem and thus not fit
3983                          in a signed 16bit value.  This is currently over
3984                          conservative.  */
3985                       if ((value & 0x8000) == 0)
3986                         {
3987                           /* Note that we've changed the relocation contents,
3988                              etc.  */
3989                           elf_section_data (sec)->relocs = internal_relocs;
3990                           elf_section_data (sec)->this_hdr.contents = contents;
3991                           symtab_hdr->contents = (unsigned char *) isymbuf;
3992
3993                           /* Fix the opcode.  */
3994                           bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3995                           bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3996
3997                           /* Fix the relocation's type.  */
3998                           irel->r_info =
3999                             ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4000                                           (ELF32_R_TYPE (irel->r_info)
4001                                            == (int) R_MN10300_GOTOFF32)
4002                                           ? R_MN10300_GOTOFF24
4003                                           : (ELF32_R_TYPE (irel->r_info)
4004                                              == (int) R_MN10300_GOT32)
4005                                           ? R_MN10300_GOT24 :
4006                                           R_MN10300_24);
4007
4008                           /* Delete one byte of data.  */
4009                           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4010                                                                irel->r_offset + 3, 1))
4011                             goto error_return;
4012
4013                           /* That will change things, so, we should relax
4014                              again.  Note that this is not required, and it
4015                              may be slow.  */
4016                           *again = TRUE;
4017                           break;
4018                         }
4019                     }
4020                 }
4021             }
4022
4023           /* See if the value will fit in 16 bits.
4024              We allow any 16bit match here.  We prune those we can't
4025              handle below.  */
4026           if ((long) value < 0x7fff && (long) value > -0x8000)
4027             {
4028               unsigned char code;
4029
4030               /* Most insns which have 32bit operands are 6 bytes long;
4031                  exceptions are pcrel insns and bit insns.
4032
4033                  We handle pcrel insns above.  We don't bother trying
4034                  to handle the bit insns here.
4035
4036                  The first byte of the remaining insns will be 0xfc.  */
4037
4038               /* Get the first opcode.  */
4039               code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
4040
4041               if (code != 0xfc)
4042                 continue;
4043
4044               /* Get the second opcode.  */
4045               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
4046
4047               if ((code & 0xf0) < 0x80)
4048                 switch (code & 0xf0)
4049                   {
4050                   /* mov (d32,am),dn   -> mov (d32,am),dn
4051                      mov dm,(d32,am)   -> mov dn,(d32,am)
4052                      mov (d32,am),an   -> mov (d32,am),an
4053                      mov dm,(d32,am)   -> mov dn,(d32,am)
4054                      movbu (d32,am),dn -> movbu (d32,am),dn
4055                      movbu dm,(d32,am) -> movbu dn,(d32,am)
4056                      movhu (d32,am),dn -> movhu (d32,am),dn
4057                      movhu dm,(d32,am) -> movhu dn,(d32,am) */
4058                   case 0x00:
4059                   case 0x10:
4060                   case 0x20:
4061                   case 0x30:
4062                   case 0x40:
4063                   case 0x50:
4064                   case 0x60:
4065                   case 0x70:
4066                     /* Not safe if the high bit is on as relaxing may
4067                        move the value out of high mem and thus not fit
4068                        in a signed 16bit value.  */
4069                     if (code == 0xcc
4070                         && (value & 0x8000))
4071                       continue;
4072
4073                     /* Note that we've changed the relocation contents, etc.  */
4074                     elf_section_data (sec)->relocs = internal_relocs;
4075                     elf_section_data (sec)->this_hdr.contents = contents;
4076                     symtab_hdr->contents = (unsigned char *) isymbuf;
4077
4078                     /* Fix the opcode.  */
4079                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4080                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4081
4082                     /* Fix the relocation's type.  */
4083                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4084                                                  (ELF32_R_TYPE (irel->r_info)
4085                                                   == (int) R_MN10300_GOTOFF32)
4086                                                  ? R_MN10300_GOTOFF16
4087                                                  : (ELF32_R_TYPE (irel->r_info)
4088                                                     == (int) R_MN10300_GOT32)
4089                                                  ? R_MN10300_GOT16
4090                                                  : (ELF32_R_TYPE (irel->r_info)
4091                                                     == (int) R_MN10300_GOTPC32)
4092                                                  ? R_MN10300_GOTPC16 :
4093                                                  R_MN10300_16);
4094
4095                     /* Delete two bytes of data.  */
4096                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4097                                                          irel->r_offset + 2, 2))
4098                       goto error_return;
4099
4100                     /* That will change things, so, we should relax again.
4101                        Note that this is not required, and it may be slow.  */
4102                     *again = TRUE;
4103                     break;
4104                   }
4105               else if ((code & 0xf0) == 0x80
4106                        || (code & 0xf0) == 0x90)
4107                 switch (code & 0xf3)
4108                   {
4109                   /* mov dn,(abs32)   -> mov dn,(abs16)
4110                      movbu dn,(abs32) -> movbu dn,(abs16)
4111                      movhu dn,(abs32) -> movhu dn,(abs16)  */
4112                   case 0x81:
4113                   case 0x82:
4114                   case 0x83:
4115                     /* Note that we've changed the relocation contents, etc.  */
4116                     elf_section_data (sec)->relocs = internal_relocs;
4117                     elf_section_data (sec)->this_hdr.contents = contents;
4118                     symtab_hdr->contents = (unsigned char *) isymbuf;
4119
4120                     if ((code & 0xf3) == 0x81)
4121                       code = 0x01 + (code & 0x0c);
4122                     else if ((code & 0xf3) == 0x82)
4123                       code = 0x02 + (code & 0x0c);
4124                     else if ((code & 0xf3) == 0x83)
4125                       code = 0x03 + (code & 0x0c);
4126                     else
4127                       abort ();
4128
4129                     /* Fix the opcode.  */
4130                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
4131
4132                     /* Fix the relocation's type.  */
4133                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4134                                                  (ELF32_R_TYPE (irel->r_info)
4135                                                   == (int) R_MN10300_GOTOFF32)
4136                                                  ? R_MN10300_GOTOFF16
4137                                                  : (ELF32_R_TYPE (irel->r_info)
4138                                                     == (int) R_MN10300_GOT32)
4139                                                  ? R_MN10300_GOT16
4140                                                  : (ELF32_R_TYPE (irel->r_info)
4141                                                     == (int) R_MN10300_GOTPC32)
4142                                                  ? R_MN10300_GOTPC16 :
4143                                                  R_MN10300_16);
4144
4145                     /* The opcode got shorter too, so we have to fix the
4146                        addend and offset too!  */
4147                     irel->r_offset -= 1;
4148
4149                     /* Delete three bytes of data.  */
4150                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4151                                                          irel->r_offset + 1, 3))
4152                       goto error_return;
4153
4154                     /* That will change things, so, we should relax again.
4155                        Note that this is not required, and it may be slow.  */
4156                     *again = TRUE;
4157                     break;
4158
4159                   /* mov am,(abs32)    -> mov am,(abs16)
4160                      mov am,(d32,sp)   -> mov am,(d16,sp)
4161                      mov dm,(d32,sp)   -> mov dm,(d32,sp)
4162                      movbu dm,(d32,sp) -> movbu dm,(d32,sp)
4163                      movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
4164                   case 0x80:
4165                   case 0x90:
4166                   case 0x91:
4167                   case 0x92:
4168                   case 0x93:
4169                     /* sp-based offsets are zero-extended.  */
4170                     if (code >= 0x90 && code <= 0x93
4171                         && (long) value < 0)
4172                       continue;
4173
4174                     /* Note that we've changed the relocation contents, etc.  */
4175                     elf_section_data (sec)->relocs = internal_relocs;
4176                     elf_section_data (sec)->this_hdr.contents = contents;
4177                     symtab_hdr->contents = (unsigned char *) isymbuf;
4178
4179                     /* Fix the opcode.  */
4180                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4181                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4182
4183                     /* Fix the relocation's type.  */
4184                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4185                                                  (ELF32_R_TYPE (irel->r_info)
4186                                                   == (int) R_MN10300_GOTOFF32)
4187                                                  ? R_MN10300_GOTOFF16
4188                                                  : (ELF32_R_TYPE (irel->r_info)
4189                                                     == (int) R_MN10300_GOT32)
4190                                                  ? R_MN10300_GOT16
4191                                                  : (ELF32_R_TYPE (irel->r_info)
4192                                                     == (int) R_MN10300_GOTPC32)
4193                                                  ? R_MN10300_GOTPC16 :
4194                                                  R_MN10300_16);
4195
4196                     /* Delete two bytes of data.  */
4197                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4198                                                          irel->r_offset + 2, 2))
4199                       goto error_return;
4200
4201                     /* That will change things, so, we should relax again.
4202                        Note that this is not required, and it may be slow.  */
4203                     *again = TRUE;
4204                     break;
4205                   }
4206               else if ((code & 0xf0) < 0xf0)
4207                 switch (code & 0xfc)
4208                   {
4209                   /* mov imm32,dn     -> mov imm16,dn
4210                      mov imm32,an     -> mov imm16,an
4211                      mov (abs32),dn   -> mov (abs16),dn
4212                      movbu (abs32),dn -> movbu (abs16),dn
4213                      movhu (abs32),dn -> movhu (abs16),dn  */
4214                   case 0xcc:
4215                   case 0xdc:
4216                   case 0xa4:
4217                   case 0xa8:
4218                   case 0xac:
4219                     /* Not safe if the high bit is on as relaxing may
4220                        move the value out of high mem and thus not fit
4221                        in a signed 16bit value.  */
4222                     if (code == 0xcc
4223                         && (value & 0x8000))
4224                       continue;
4225
4226                     /* "mov imm16, an" zero-extends the immediate.  */
4227                     if ((code & 0xfc) == 0xdc
4228                         && (long) value < 0)
4229                       continue;
4230
4231                     /* Note that we've changed the relocation contents, etc.  */
4232                     elf_section_data (sec)->relocs = internal_relocs;
4233                     elf_section_data (sec)->this_hdr.contents = contents;
4234                     symtab_hdr->contents = (unsigned char *) isymbuf;
4235
4236                     if ((code & 0xfc) == 0xcc)
4237                       code = 0x2c + (code & 0x03);
4238                     else if ((code & 0xfc) == 0xdc)
4239                       code = 0x24 + (code & 0x03);
4240                     else if ((code & 0xfc) == 0xa4)
4241                       code = 0x30 + (code & 0x03);
4242                     else if ((code & 0xfc) == 0xa8)
4243                       code = 0x34 + (code & 0x03);
4244                     else if ((code & 0xfc) == 0xac)
4245                       code = 0x38 + (code & 0x03);
4246                     else
4247                       abort ();
4248
4249                     /* Fix the opcode.  */
4250                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
4251
4252                     /* Fix the relocation's type.  */
4253                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4254                                                  (ELF32_R_TYPE (irel->r_info)
4255                                                   == (int) R_MN10300_GOTOFF32)
4256                                                  ? R_MN10300_GOTOFF16
4257                                                  : (ELF32_R_TYPE (irel->r_info)
4258                                                     == (int) R_MN10300_GOT32)
4259                                                  ? R_MN10300_GOT16
4260                                                  : (ELF32_R_TYPE (irel->r_info)
4261                                                     == (int) R_MN10300_GOTPC32)
4262                                                  ? R_MN10300_GOTPC16 :
4263                                                  R_MN10300_16);
4264
4265                     /* The opcode got shorter too, so we have to fix the
4266                        addend and offset too!  */
4267                     irel->r_offset -= 1;
4268
4269                     /* Delete three bytes of data.  */
4270                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4271                                                          irel->r_offset + 1, 3))
4272                       goto error_return;
4273
4274                     /* That will change things, so, we should relax again.
4275                        Note that this is not required, and it may be slow.  */
4276                     *again = TRUE;
4277                     break;
4278
4279                   /* mov (abs32),an    -> mov (abs16),an
4280                      mov (d32,sp),an   -> mov (d16,sp),an
4281                      mov (d32,sp),dn   -> mov (d16,sp),dn
4282                      movbu (d32,sp),dn -> movbu (d16,sp),dn
4283                      movhu (d32,sp),dn -> movhu (d16,sp),dn
4284                      add imm32,dn      -> add imm16,dn
4285                      cmp imm32,dn      -> cmp imm16,dn
4286                      add imm32,an      -> add imm16,an
4287                      cmp imm32,an      -> cmp imm16,an
4288                      and imm32,dn      -> and imm16,dn
4289                      or imm32,dn       -> or imm16,dn
4290                      xor imm32,dn      -> xor imm16,dn
4291                      btst imm32,dn     -> btst imm16,dn */
4292
4293                   case 0xa0:
4294                   case 0xb0:
4295                   case 0xb1:
4296                   case 0xb2:
4297                   case 0xb3:
4298                   case 0xc0:
4299                   case 0xc8:
4300
4301                   case 0xd0:
4302                   case 0xd8:
4303                   case 0xe0:
4304                   case 0xe1:
4305                   case 0xe2:
4306                   case 0xe3:
4307                     /* cmp imm16, an zero-extends the immediate.  */
4308                     if (code == 0xdc
4309                         && (long) value < 0)
4310                       continue;
4311
4312                     /* So do sp-based offsets.  */
4313                     if (code >= 0xb0 && code <= 0xb3
4314                         && (long) value < 0)
4315                       continue;
4316
4317                     /* Note that we've changed the relocation contents, etc.  */
4318                     elf_section_data (sec)->relocs = internal_relocs;
4319                     elf_section_data (sec)->this_hdr.contents = contents;
4320                     symtab_hdr->contents = (unsigned char *) isymbuf;
4321
4322                     /* Fix the opcode.  */
4323                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4324                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4325
4326                     /* Fix the relocation's type.  */
4327                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4328                                                  (ELF32_R_TYPE (irel->r_info)
4329                                                   == (int) R_MN10300_GOTOFF32)
4330                                                  ? R_MN10300_GOTOFF16
4331                                                  : (ELF32_R_TYPE (irel->r_info)
4332                                                     == (int) R_MN10300_GOT32)
4333                                                  ? R_MN10300_GOT16
4334                                                  : (ELF32_R_TYPE (irel->r_info)
4335                                                     == (int) R_MN10300_GOTPC32)
4336                                                  ? R_MN10300_GOTPC16 :
4337                                                  R_MN10300_16);
4338
4339                     /* Delete two bytes of data.  */
4340                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4341                                                          irel->r_offset + 2, 2))
4342                       goto error_return;
4343
4344                     /* That will change things, so, we should relax again.
4345                        Note that this is not required, and it may be slow.  */
4346                     *again = TRUE;
4347                     break;
4348                   }
4349               else if (code == 0xfe)
4350                 {
4351                   /* add imm32,sp -> add imm16,sp  */
4352
4353                   /* Note that we've changed the relocation contents, etc.  */
4354                   elf_section_data (sec)->relocs = internal_relocs;
4355                   elf_section_data (sec)->this_hdr.contents = contents;
4356                   symtab_hdr->contents = (unsigned char *) isymbuf;
4357
4358                   /* Fix the opcode.  */
4359                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4360                   bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
4361
4362                   /* Fix the relocation's type.  */
4363                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4364                                                (ELF32_R_TYPE (irel->r_info)
4365                                                 == (int) R_MN10300_GOT32)
4366                                                ? R_MN10300_GOT16
4367                                                : (ELF32_R_TYPE (irel->r_info)
4368                                                   == (int) R_MN10300_GOTOFF32)
4369                                                ? R_MN10300_GOTOFF16
4370                                                : (ELF32_R_TYPE (irel->r_info)
4371                                                   == (int) R_MN10300_GOTPC32)
4372                                                ? R_MN10300_GOTPC16 :
4373                                                R_MN10300_16);
4374
4375                   /* Delete two bytes of data.  */
4376                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4377                                                        irel->r_offset + 2, 2))
4378                     goto error_return;
4379
4380                   /* That will change things, so, we should relax again.
4381                      Note that this is not required, and it may be slow.  */
4382                   *again = TRUE;
4383                   break;
4384                 }
4385             }
4386         }
4387     }
4388
4389   if (isymbuf != NULL
4390       && symtab_hdr->contents != (unsigned char *) isymbuf)
4391     {
4392       if (! link_info->keep_memory)
4393         free (isymbuf);
4394       else
4395         {
4396           /* Cache the symbols for elf_link_input_bfd.  */
4397           symtab_hdr->contents = (unsigned char *) isymbuf;
4398         }
4399     }
4400
4401   if (contents != NULL
4402       && elf_section_data (sec)->this_hdr.contents != contents)
4403     {
4404       if (! link_info->keep_memory)
4405         free (contents);
4406       else
4407         {
4408           /* Cache the section contents for elf_link_input_bfd.  */
4409           elf_section_data (sec)->this_hdr.contents = contents;
4410         }
4411     }
4412
4413   if (internal_relocs != NULL
4414       && elf_section_data (sec)->relocs != internal_relocs)
4415     free (internal_relocs);
4416
4417   return TRUE;
4418
4419  error_return:
4420   if (isymbuf != NULL
4421       && symtab_hdr->contents != (unsigned char *) isymbuf)
4422     free (isymbuf);
4423   if (contents != NULL
4424       && elf_section_data (section)->this_hdr.contents != contents)
4425     free (contents);
4426   if (internal_relocs != NULL
4427       && elf_section_data (section)->relocs != internal_relocs)
4428     free (internal_relocs);
4429
4430   return FALSE;
4431 }
4432
4433 /* This is a version of bfd_generic_get_relocated_section_contents
4434    which uses mn10300_elf_relocate_section.  */
4435
4436 static bfd_byte *
4437 mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
4438                                             struct bfd_link_info *link_info,
4439                                             struct bfd_link_order *link_order,
4440                                             bfd_byte *data,
4441                                             bfd_boolean relocatable,
4442                                             asymbol **symbols)
4443 {
4444   Elf_Internal_Shdr *symtab_hdr;
4445   asection *input_section = link_order->u.indirect.section;
4446   bfd *input_bfd = input_section->owner;
4447   asection **sections = NULL;
4448   Elf_Internal_Rela *internal_relocs = NULL;
4449   Elf_Internal_Sym *isymbuf = NULL;
4450
4451   /* We only need to handle the case of relaxing, or of having a
4452      particular set of section contents, specially.  */
4453   if (relocatable
4454       || elf_section_data (input_section)->this_hdr.contents == NULL)
4455     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
4456                                                        link_order, data,
4457                                                        relocatable,
4458                                                        symbols);
4459
4460   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4461
4462   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
4463           (size_t) input_section->size);
4464
4465   if ((input_section->flags & SEC_RELOC) != 0
4466       && input_section->reloc_count > 0)
4467     {
4468       asection **secpp;
4469       Elf_Internal_Sym *isym, *isymend;
4470       bfd_size_type amt;
4471
4472       internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
4473                                                    NULL, NULL, FALSE);
4474       if (internal_relocs == NULL)
4475         goto error_return;
4476
4477       if (symtab_hdr->sh_info != 0)
4478         {
4479           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4480           if (isymbuf == NULL)
4481             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4482                                             symtab_hdr->sh_info, 0,
4483                                             NULL, NULL, NULL);
4484           if (isymbuf == NULL)
4485             goto error_return;
4486         }
4487
4488       amt = symtab_hdr->sh_info;
4489       amt *= sizeof (asection *);
4490       sections = bfd_malloc (amt);
4491       if (sections == NULL && amt != 0)
4492         goto error_return;
4493
4494       isymend = isymbuf + symtab_hdr->sh_info;
4495       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
4496         {
4497           asection *isec;
4498
4499           if (isym->st_shndx == SHN_UNDEF)
4500             isec = bfd_und_section_ptr;
4501           else if (isym->st_shndx == SHN_ABS)
4502             isec = bfd_abs_section_ptr;
4503           else if (isym->st_shndx == SHN_COMMON)
4504             isec = bfd_com_section_ptr;
4505           else
4506             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
4507
4508           *secpp = isec;
4509         }
4510
4511       if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
4512                                           input_section, data, internal_relocs,
4513                                           isymbuf, sections))
4514         goto error_return;
4515
4516       if (sections != NULL)
4517         free (sections);
4518       if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4519         free (isymbuf);
4520       if (internal_relocs != elf_section_data (input_section)->relocs)
4521         free (internal_relocs);
4522     }
4523
4524   return data;
4525
4526  error_return:
4527   if (sections != NULL)
4528     free (sections);
4529   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4530     free (isymbuf);
4531   if (internal_relocs != NULL
4532       && internal_relocs != elf_section_data (input_section)->relocs)
4533     free (internal_relocs);
4534   return NULL;
4535 }
4536
4537 /* Assorted hash table functions.  */
4538
4539 /* Initialize an entry in the link hash table.  */
4540
4541 /* Create an entry in an MN10300 ELF linker hash table.  */
4542
4543 static struct bfd_hash_entry *
4544 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
4545                                  struct bfd_hash_table *table,
4546                                  const char *string)
4547 {
4548   struct elf32_mn10300_link_hash_entry *ret =
4549     (struct elf32_mn10300_link_hash_entry *) entry;
4550
4551   /* Allocate the structure if it has not already been allocated by a
4552      subclass.  */
4553   if (ret == NULL)
4554     ret = (struct elf32_mn10300_link_hash_entry *)
4555            bfd_hash_allocate (table, sizeof (* ret));
4556   if (ret == NULL)
4557     return (struct bfd_hash_entry *) ret;
4558
4559   /* Call the allocation method of the superclass.  */
4560   ret = (struct elf32_mn10300_link_hash_entry *)
4561          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
4562                                      table, string);
4563   if (ret != NULL)
4564     {
4565       ret->direct_calls = 0;
4566       ret->stack_size = 0;
4567       ret->movm_args = 0;
4568       ret->movm_stack_size = 0;
4569       ret->flags = 0;
4570       ret->value = 0;
4571       ret->tls_type = GOT_UNKNOWN;
4572     }
4573
4574   return (struct bfd_hash_entry *) ret;
4575 }
4576
4577 static void
4578 _bfd_mn10300_copy_indirect_symbol (struct bfd_link_info *        info,
4579                                    struct elf_link_hash_entry *  dir,
4580                                    struct elf_link_hash_entry *  ind)
4581 {
4582   struct elf32_mn10300_link_hash_entry * edir;
4583   struct elf32_mn10300_link_hash_entry * eind;
4584
4585   edir = elf_mn10300_hash_entry (dir);
4586   eind = elf_mn10300_hash_entry (ind);
4587
4588   if (ind->root.type == bfd_link_hash_indirect
4589       && dir->got.refcount <= 0)
4590     {
4591       edir->tls_type = eind->tls_type;
4592       eind->tls_type = GOT_UNKNOWN;
4593     }
4594   edir->direct_calls = eind->direct_calls;
4595   edir->stack_size = eind->stack_size;
4596   edir->movm_args = eind->movm_args;
4597   edir->movm_stack_size = eind->movm_stack_size;
4598   edir->flags = eind->flags;
4599
4600   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
4601 }
4602
4603 /* Destroy an mn10300 ELF linker hash table.  */
4604
4605 static void
4606 elf32_mn10300_link_hash_table_free (bfd *obfd)
4607 {
4608   struct elf32_mn10300_link_hash_table *ret
4609     = (struct elf32_mn10300_link_hash_table *) obfd->link.hash;
4610
4611   obfd->link.hash = &ret->static_hash_table->root.root;
4612   _bfd_elf_link_hash_table_free (obfd);
4613   obfd->is_linker_output = TRUE;
4614   obfd->link.hash = &ret->root.root;
4615   _bfd_elf_link_hash_table_free (obfd);
4616 }
4617
4618 /* Create an mn10300 ELF linker hash table.  */
4619
4620 static struct bfd_link_hash_table *
4621 elf32_mn10300_link_hash_table_create (bfd *abfd)
4622 {
4623   struct elf32_mn10300_link_hash_table *ret;
4624   bfd_size_type amt = sizeof (* ret);
4625
4626   ret = bfd_zmalloc (amt);
4627   if (ret == NULL)
4628     return NULL;
4629
4630   amt = sizeof (struct elf_link_hash_table);
4631   ret->static_hash_table = bfd_zmalloc (amt);
4632   if (ret->static_hash_table == NULL)
4633     {
4634       free (ret);
4635       return NULL;
4636     }
4637
4638   if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
4639                                       elf32_mn10300_link_hash_newfunc,
4640                                       sizeof (struct elf32_mn10300_link_hash_entry),
4641                                       MN10300_ELF_DATA))
4642     {
4643       free (ret->static_hash_table);
4644       free (ret);
4645       return NULL;
4646     }
4647
4648   abfd->is_linker_output = FALSE;
4649   abfd->link.hash = NULL;
4650   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
4651                                       elf32_mn10300_link_hash_newfunc,
4652                                       sizeof (struct elf32_mn10300_link_hash_entry),
4653                                       MN10300_ELF_DATA))
4654     {
4655       abfd->is_linker_output = TRUE;
4656       abfd->link.hash = &ret->static_hash_table->root.root;
4657       _bfd_elf_link_hash_table_free (abfd);
4658       free (ret);
4659       return NULL;
4660     }
4661   ret->root.root.hash_table_free = elf32_mn10300_link_hash_table_free;
4662
4663   ret->tls_ldm_got.offset = -1;
4664
4665   return & ret->root.root;
4666 }
4667
4668 static unsigned long
4669 elf_mn10300_mach (flagword flags)
4670 {
4671   switch (flags & EF_MN10300_MACH)
4672     {
4673     case E_MN10300_MACH_MN10300:
4674     default:
4675       return bfd_mach_mn10300;
4676
4677     case E_MN10300_MACH_AM33:
4678       return bfd_mach_am33;
4679
4680     case E_MN10300_MACH_AM33_2:
4681       return bfd_mach_am33_2;
4682     }
4683 }
4684
4685 /* The final processing done just before writing out a MN10300 ELF object
4686    file.  This gets the MN10300 architecture right based on the machine
4687    number.  */
4688
4689 static void
4690 _bfd_mn10300_elf_final_write_processing (bfd *abfd,
4691                                          bfd_boolean linker ATTRIBUTE_UNUSED)
4692 {
4693   unsigned long val;
4694
4695   switch (bfd_get_mach (abfd))
4696     {
4697     default:
4698     case bfd_mach_mn10300:
4699       val = E_MN10300_MACH_MN10300;
4700       break;
4701
4702     case bfd_mach_am33:
4703       val = E_MN10300_MACH_AM33;
4704       break;
4705
4706     case bfd_mach_am33_2:
4707       val = E_MN10300_MACH_AM33_2;
4708       break;
4709     }
4710
4711   elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
4712   elf_elfheader (abfd)->e_flags |= val;
4713 }
4714
4715 static bfd_boolean
4716 _bfd_mn10300_elf_object_p (bfd *abfd)
4717 {
4718   bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
4719                              elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
4720   return TRUE;
4721 }
4722
4723 /* Merge backend specific data from an object file to the output
4724    object file when linking.  */
4725
4726 static bfd_boolean
4727 _bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4728 {
4729   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4730       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4731     return TRUE;
4732
4733   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4734       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
4735     {
4736       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4737                                bfd_get_mach (ibfd)))
4738         return FALSE;
4739     }
4740
4741   return TRUE;
4742 }
4743
4744 #define PLT0_ENTRY_SIZE     15
4745 #define PLT_ENTRY_SIZE      20
4746 #define PIC_PLT_ENTRY_SIZE  24
4747
4748 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
4749 {
4750   0xfc, 0xa0, 0, 0, 0, 0,       /* mov  (.got+8),a0 */
4751   0xfe, 0xe, 0x10, 0, 0, 0, 0,  /* mov  (.got+4),r1 */
4752   0xf0, 0xf4,                   /* jmp  (a0) */
4753 };
4754
4755 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
4756 {
4757   0xfc, 0xa0, 0, 0, 0, 0,       /* mov  (nameN@GOT + .got),a0 */
4758   0xf0, 0xf4,                   /* jmp  (a0) */
4759   0xfe, 8, 0, 0, 0, 0, 0,       /* mov  reloc-table-address,r0 */
4760   0xdc, 0, 0, 0, 0,             /* jmp  .plt0 */
4761 };
4762
4763 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4764 {
4765   0xfc, 0x22, 0, 0, 0, 0,       /* mov  (nameN@GOT,a2),a0 */
4766   0xf0, 0xf4,                   /* jmp  (a0) */
4767   0xfe, 8, 0, 0, 0, 0, 0,       /* mov  reloc-table-address,r0 */
4768   0xf8, 0x22, 8,                /* mov  (8,a2),a0 */
4769   0xfb, 0xa, 0x1a, 4,           /* mov  (4,a2),r1 */
4770   0xf0, 0xf4,                   /* jmp  (a0) */
4771 };
4772
4773 /* Return size of the first PLT entry.  */
4774 #define elf_mn10300_sizeof_plt0(info) \
4775   (bfd_link_pic (info) ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4776
4777 /* Return size of a PLT entry.  */
4778 #define elf_mn10300_sizeof_plt(info) \
4779   (bfd_link_pic (info) ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4780
4781 /* Return offset of the PLT0 address in an absolute PLT entry.  */
4782 #define elf_mn10300_plt_plt0_offset(info) 16
4783
4784 /* Return offset of the linker in PLT0 entry.  */
4785 #define elf_mn10300_plt0_linker_offset(info) 2
4786
4787 /* Return offset of the GOT id in PLT0 entry.  */
4788 #define elf_mn10300_plt0_gotid_offset(info) 9
4789
4790 /* Return offset of the temporary in PLT entry.  */
4791 #define elf_mn10300_plt_temp_offset(info) 8
4792
4793 /* Return offset of the symbol in PLT entry.  */
4794 #define elf_mn10300_plt_symbol_offset(info) 2
4795
4796 /* Return offset of the relocation in PLT entry.  */
4797 #define elf_mn10300_plt_reloc_offset(info) 11
4798
4799 /* The name of the dynamic interpreter.  This is put in the .interp
4800    section.  */
4801
4802 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4803
4804 /* Create dynamic sections when linking against a dynamic object.  */
4805
4806 static bfd_boolean
4807 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4808 {
4809   flagword   flags;
4810   asection * s;
4811   const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4812   struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
4813   int ptralign = 0;
4814
4815   switch (bed->s->arch_size)
4816     {
4817     case 32:
4818       ptralign = 2;
4819       break;
4820
4821     case 64:
4822       ptralign = 3;
4823       break;
4824
4825     default:
4826       bfd_set_error (bfd_error_bad_value);
4827       return FALSE;
4828     }
4829
4830   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4831      .rel[a].bss sections.  */
4832   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4833            | SEC_LINKER_CREATED);
4834
4835   s = bfd_make_section_anyway_with_flags (abfd,
4836                                           (bed->default_use_rela_p
4837                                            ? ".rela.plt" : ".rel.plt"),
4838                                           flags | SEC_READONLY);
4839   htab->root.srelplt = s;
4840   if (s == NULL
4841       || ! bfd_set_section_alignment (abfd, s, ptralign))
4842     return FALSE;
4843
4844   if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4845     return FALSE;
4846
4847   if (bed->want_dynbss)
4848     {
4849       /* The .dynbss section is a place to put symbols which are defined
4850          by dynamic objects, are referenced by regular objects, and are
4851          not functions.  We must allocate space for them in the process
4852          image and use a R_*_COPY reloc to tell the dynamic linker to
4853          initialize them at run time.  The linker script puts the .dynbss
4854          section into the .bss section of the final image.  */
4855       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
4856                                               SEC_ALLOC | SEC_LINKER_CREATED);
4857       if (s == NULL)
4858         return FALSE;
4859
4860       /* The .rel[a].bss section holds copy relocs.  This section is not
4861          normally needed.  We need to create it here, though, so that the
4862          linker will map it to an output section.  We can't just create it
4863          only if we need it, because we will not know whether we need it
4864          until we have seen all the input files, and the first time the
4865          main linker code calls BFD after examining all the input files
4866          (size_dynamic_sections) the input sections have already been
4867          mapped to the output sections.  If the section turns out not to
4868          be needed, we can discard it later.  We will never need this
4869          section when generating a shared object, since they do not use
4870          copy relocs.  */
4871       if (! bfd_link_pic (info))
4872         {
4873           s = bfd_make_section_anyway_with_flags (abfd,
4874                                                   (bed->default_use_rela_p
4875                                                    ? ".rela.bss" : ".rel.bss"),
4876                                                   flags | SEC_READONLY);
4877           if (s == NULL
4878               || ! bfd_set_section_alignment (abfd, s, ptralign))
4879             return FALSE;
4880         }
4881     }
4882
4883   return TRUE;
4884 }
4885 \f
4886 /* Adjust a symbol defined by a dynamic object and referenced by a
4887    regular object.  The current definition is in some section of the
4888    dynamic object, but we're not including those sections.  We have to
4889    change the definition to something the rest of the link can
4890    understand.  */
4891
4892 static bfd_boolean
4893 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4894                                         struct elf_link_hash_entry * h)
4895 {
4896   struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
4897   bfd * dynobj;
4898   asection * s;
4899
4900   dynobj = htab->root.dynobj;
4901
4902   /* Make sure we know what is going on here.  */
4903   BFD_ASSERT (dynobj != NULL
4904               && (h->needs_plt
4905                   || h->u.weakdef != NULL
4906                   || (h->def_dynamic
4907                       && h->ref_regular
4908                       && !h->def_regular)));
4909
4910   /* If this is a function, put it in the procedure linkage table.  We
4911      will fill in the contents of the procedure linkage table later,
4912      when we know the address of the .got section.  */
4913   if (h->type == STT_FUNC
4914       || h->needs_plt)
4915     {
4916       if (! bfd_link_pic (info)
4917           && !h->def_dynamic
4918           && !h->ref_dynamic)
4919         {
4920           /* This case can occur if we saw a PLT reloc in an input
4921              file, but the symbol was never referred to by a dynamic
4922              object.  In such a case, we don't actually need to build
4923              a procedure linkage table, and we can just do a REL32
4924              reloc instead.  */
4925           BFD_ASSERT (h->needs_plt);
4926           return TRUE;
4927         }
4928
4929       /* Make sure this symbol is output as a dynamic symbol.  */
4930       if (h->dynindx == -1)
4931         {
4932           if (! bfd_elf_link_record_dynamic_symbol (info, h))
4933             return FALSE;
4934         }
4935
4936       s = htab->root.splt;
4937       BFD_ASSERT (s != NULL);
4938
4939       /* If this is the first .plt entry, make room for the special
4940          first entry.  */
4941       if (s->size == 0)
4942         s->size += elf_mn10300_sizeof_plt0 (info);
4943
4944       /* If this symbol is not defined in a regular file, and we are
4945          not generating a shared library, then set the symbol to this
4946          location in the .plt.  This is required to make function
4947          pointers compare as equal between the normal executable and
4948          the shared library.  */
4949       if (! bfd_link_pic (info)
4950           && !h->def_regular)
4951         {
4952           h->root.u.def.section = s;
4953           h->root.u.def.value = s->size;
4954         }
4955
4956       h->plt.offset = s->size;
4957
4958       /* Make room for this entry.  */
4959       s->size += elf_mn10300_sizeof_plt (info);
4960
4961       /* We also need to make an entry in the .got.plt section, which
4962          will be placed in the .got section by the linker script.  */
4963       s = htab->root.sgotplt;
4964       BFD_ASSERT (s != NULL);
4965       s->size += 4;
4966
4967       /* We also need to make an entry in the .rela.plt section.  */
4968       s = bfd_get_linker_section (dynobj, ".rela.plt");
4969       BFD_ASSERT (s != NULL);
4970       s->size += sizeof (Elf32_External_Rela);
4971
4972       return TRUE;
4973     }
4974
4975   /* If this is a weak symbol, and there is a real definition, the
4976      processor independent code will have arranged for us to see the
4977      real definition first, and we can just use the same value.  */
4978   if (h->u.weakdef != NULL)
4979     {
4980       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4981                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
4982       h->root.u.def.section = h->u.weakdef->root.u.def.section;
4983       h->root.u.def.value = h->u.weakdef->root.u.def.value;
4984       return TRUE;
4985     }
4986
4987   /* This is a reference to a symbol defined by a dynamic object which
4988      is not a function.  */
4989
4990   /* If we are creating a shared library, we must presume that the
4991      only references to the symbol are via the global offset table.
4992      For such cases we need not do anything here; the relocations will
4993      be handled correctly by relocate_section.  */
4994   if (bfd_link_pic (info))
4995     return TRUE;
4996
4997   /* If there are no references to this symbol that do not use the
4998      GOT, we don't need to generate a copy reloc.  */
4999   if (!h->non_got_ref)
5000     return TRUE;
5001
5002   /* We must allocate the symbol in our .dynbss section, which will
5003      become part of the .bss section of the executable.  There will be
5004      an entry for this symbol in the .dynsym section.  The dynamic
5005      object will contain position independent code, so all references
5006      from the dynamic object to this symbol will go through the global
5007      offset table.  The dynamic linker will use the .dynsym entry to
5008      determine the address it must put in the global offset table, so
5009      both the dynamic object and the regular object will refer to the
5010      same memory location for the variable.  */
5011
5012   s = bfd_get_linker_section (dynobj, ".dynbss");
5013   BFD_ASSERT (s != NULL);
5014
5015   /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
5016      copy the initial value out of the dynamic object and into the
5017      runtime process image.  We need to remember the offset into the
5018      .rela.bss section we are going to use.  */
5019   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
5020     {
5021       asection * srel;
5022
5023       srel = bfd_get_linker_section (dynobj, ".rela.bss");
5024       BFD_ASSERT (srel != NULL);
5025       srel->size += sizeof (Elf32_External_Rela);
5026       h->needs_copy = 1;
5027     }
5028
5029   return _bfd_elf_adjust_dynamic_copy (info, h, s);
5030 }
5031
5032 /* Set the sizes of the dynamic sections.  */
5033
5034 static bfd_boolean
5035 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
5036                                         struct bfd_link_info * info)
5037 {
5038   struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
5039   bfd * dynobj;
5040   asection * s;
5041   bfd_boolean plt;
5042   bfd_boolean relocs;
5043   bfd_boolean reltext;
5044
5045   dynobj = htab->root.dynobj;
5046   BFD_ASSERT (dynobj != NULL);
5047
5048   if (elf_hash_table (info)->dynamic_sections_created)
5049     {
5050       /* Set the contents of the .interp section to the interpreter.  */
5051       if (bfd_link_executable (info))
5052         {
5053           s = bfd_get_linker_section (dynobj, ".interp");
5054           BFD_ASSERT (s != NULL);
5055           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5056           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5057         }
5058     }
5059   else
5060     {
5061       /* We may have created entries in the .rela.got section.
5062          However, if we are not creating the dynamic sections, we will
5063          not actually use these entries.  Reset the size of .rela.got,
5064          which will cause it to get stripped from the output file
5065          below.  */
5066       s = htab->root.sgot;
5067       if (s != NULL)
5068         s->size = 0;
5069     }
5070
5071   if (htab->tls_ldm_got.refcount > 0)
5072     {
5073       s = bfd_get_linker_section (dynobj, ".rela.got");
5074       BFD_ASSERT (s != NULL);
5075       s->size += sizeof (Elf32_External_Rela);
5076     }
5077
5078   /* The check_relocs and adjust_dynamic_symbol entry points have
5079      determined the sizes of the various dynamic sections.  Allocate
5080      memory for them.  */
5081   plt = FALSE;
5082   relocs = FALSE;
5083   reltext = FALSE;
5084   for (s = dynobj->sections; s != NULL; s = s->next)
5085     {
5086       const char * name;
5087
5088       if ((s->flags & SEC_LINKER_CREATED) == 0)
5089         continue;
5090
5091       /* It's OK to base decisions on the section name, because none
5092          of the dynobj section names depend upon the input files.  */
5093       name = bfd_get_section_name (dynobj, s);
5094
5095       if (streq (name, ".plt"))
5096         {
5097           /* Remember whether there is a PLT.  */
5098           plt = s->size != 0;
5099         }
5100       else if (CONST_STRNEQ (name, ".rela"))
5101         {
5102           if (s->size != 0)
5103             {
5104               asection * target;
5105
5106               /* Remember whether there are any reloc sections other
5107                  than .rela.plt.  */
5108               if (! streq (name, ".rela.plt"))
5109                 {
5110                   const char * outname;
5111
5112                   relocs = TRUE;
5113
5114                   /* If this relocation section applies to a read only
5115                      section, then we probably need a DT_TEXTREL
5116                      entry.  The entries in the .rela.plt section
5117                      really apply to the .got section, which we
5118                      created ourselves and so know is not readonly.  */
5119                   outname = bfd_get_section_name (output_bfd,
5120                                                   s->output_section);
5121                   target = bfd_get_section_by_name (output_bfd, outname + 5);
5122                   if (target != NULL
5123                       && (target->flags & SEC_READONLY) != 0
5124                       && (target->flags & SEC_ALLOC) != 0)
5125                     reltext = TRUE;
5126                 }
5127
5128               /* We use the reloc_count field as a counter if we need
5129                  to copy relocs into the output file.  */
5130               s->reloc_count = 0;
5131             }
5132         }
5133       else if (! CONST_STRNEQ (name, ".got")
5134                && ! streq (name, ".dynbss"))
5135         /* It's not one of our sections, so don't allocate space.  */
5136         continue;
5137
5138       if (s->size == 0)
5139         {
5140           /* If we don't need this section, strip it from the
5141              output file.  This is mostly to handle .rela.bss and
5142              .rela.plt.  We must create both sections in
5143              create_dynamic_sections, because they must be created
5144              before the linker maps input sections to output
5145              sections.  The linker does that before
5146              adjust_dynamic_symbol is called, and it is that
5147              function which decides whether anything needs to go
5148              into these sections.  */
5149           s->flags |= SEC_EXCLUDE;
5150           continue;
5151         }
5152
5153         if ((s->flags & SEC_HAS_CONTENTS) == 0)
5154           continue;
5155
5156       /* Allocate memory for the section contents.  We use bfd_zalloc
5157          here in case unused entries are not reclaimed before the
5158          section's contents are written out.  This should not happen,
5159          but this way if it does, we get a R_MN10300_NONE reloc
5160          instead of garbage.  */
5161       s->contents = bfd_zalloc (dynobj, s->size);
5162       if (s->contents == NULL)
5163         return FALSE;
5164     }
5165
5166   if (elf_hash_table (info)->dynamic_sections_created)
5167     {
5168       /* Add some entries to the .dynamic section.  We fill in the
5169          values later, in _bfd_mn10300_elf_finish_dynamic_sections,
5170          but we must add the entries now so that we get the correct
5171          size for the .dynamic section.  The DT_DEBUG entry is filled
5172          in by the dynamic linker and used by the debugger.  */
5173       if (! bfd_link_pic (info))
5174         {
5175           if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
5176             return FALSE;
5177         }
5178
5179       if (plt)
5180         {
5181           if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
5182               || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5183               || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
5184               || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5185             return FALSE;
5186         }
5187
5188       if (relocs)
5189         {
5190           if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
5191               || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
5192               || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
5193                                               sizeof (Elf32_External_Rela)))
5194             return FALSE;
5195         }
5196
5197       if (reltext)
5198         {
5199           if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
5200             return FALSE;
5201         }
5202     }
5203
5204   return TRUE;
5205 }
5206
5207 /* Finish up dynamic symbol handling.  We set the contents of various
5208    dynamic sections here.  */
5209
5210 static bfd_boolean
5211 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
5212                                         struct bfd_link_info * info,
5213                                         struct elf_link_hash_entry * h,
5214                                         Elf_Internal_Sym * sym)
5215 {
5216   struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
5217   bfd * dynobj;
5218
5219   dynobj = htab->root.dynobj;
5220
5221   if (h->plt.offset != (bfd_vma) -1)
5222     {
5223       asection *        splt;
5224       asection *        sgot;
5225       asection *        srel;
5226       bfd_vma           plt_index;
5227       bfd_vma           got_offset;
5228       Elf_Internal_Rela rel;
5229
5230       /* This symbol has an entry in the procedure linkage table.  Set
5231          it up.  */
5232
5233       BFD_ASSERT (h->dynindx != -1);
5234
5235       splt = htab->root.splt;
5236       sgot = htab->root.sgotplt;
5237       srel = bfd_get_linker_section (dynobj, ".rela.plt");
5238       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
5239
5240       /* Get the index in the procedure linkage table which
5241          corresponds to this symbol.  This is the index of this symbol
5242          in all the symbols for which we are making plt entries.  The
5243          first entry in the procedure linkage table is reserved.  */
5244       plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
5245                    / elf_mn10300_sizeof_plt (info));
5246
5247       /* Get the offset into the .got table of the entry that
5248          corresponds to this function.  Each .got entry is 4 bytes.
5249          The first three are reserved.  */
5250       got_offset = (plt_index + 3) * 4;
5251
5252       /* Fill in the entry in the procedure linkage table.  */
5253       if (! bfd_link_pic (info))
5254         {
5255           memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
5256                   elf_mn10300_sizeof_plt (info));
5257           bfd_put_32 (output_bfd,
5258                       (sgot->output_section->vma
5259                        + sgot->output_offset
5260                        + got_offset),
5261                       (splt->contents + h->plt.offset
5262                        + elf_mn10300_plt_symbol_offset (info)));
5263
5264           bfd_put_32 (output_bfd,
5265                       (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
5266                       (splt->contents + h->plt.offset
5267                        + elf_mn10300_plt_plt0_offset (info)));
5268         }
5269       else
5270         {
5271           memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
5272                   elf_mn10300_sizeof_plt (info));
5273
5274           bfd_put_32 (output_bfd, got_offset,
5275                       (splt->contents + h->plt.offset
5276                        + elf_mn10300_plt_symbol_offset (info)));
5277         }
5278
5279       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
5280                   (splt->contents + h->plt.offset
5281                    + elf_mn10300_plt_reloc_offset (info)));
5282
5283       /* Fill in the entry in the global offset table.  */
5284       bfd_put_32 (output_bfd,
5285                   (splt->output_section->vma
5286                    + splt->output_offset
5287                    + h->plt.offset
5288                    + elf_mn10300_plt_temp_offset (info)),
5289                   sgot->contents + got_offset);
5290
5291       /* Fill in the entry in the .rela.plt section.  */
5292       rel.r_offset = (sgot->output_section->vma
5293                       + sgot->output_offset
5294                       + got_offset);
5295       rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
5296       rel.r_addend = 0;
5297       bfd_elf32_swap_reloca_out (output_bfd, &rel,
5298                                  (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5299                                                + plt_index));
5300
5301       if (!h->def_regular)
5302         /* Mark the symbol as undefined, rather than as defined in
5303            the .plt section.  Leave the value alone.  */
5304         sym->st_shndx = SHN_UNDEF;
5305     }
5306
5307   if (h->got.offset != (bfd_vma) -1)
5308     {
5309       asection *        sgot;
5310       asection *        srel;
5311       Elf_Internal_Rela rel;
5312
5313       /* This symbol has an entry in the global offset table.  Set it up.  */
5314       sgot = htab->root.sgot;
5315       srel = bfd_get_linker_section (dynobj, ".rela.got");
5316       BFD_ASSERT (sgot != NULL && srel != NULL);
5317
5318       rel.r_offset = (sgot->output_section->vma
5319                       + sgot->output_offset
5320                       + (h->got.offset & ~1));
5321
5322       switch (elf_mn10300_hash_entry (h)->tls_type)
5323         {
5324         case GOT_TLS_GD:
5325           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5326           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset + 4);
5327           rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_DTPMOD);
5328           rel.r_addend = 0;
5329           bfd_elf32_swap_reloca_out (output_bfd, & rel,
5330                                      (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5331                                                    + srel->reloc_count));
5332           ++ srel->reloc_count;
5333           rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_DTPOFF);
5334           rel.r_offset += 4;
5335           rel.r_addend = 0;
5336           break;
5337
5338         case GOT_TLS_IE:
5339           /* We originally stored the addend in the GOT, but at this
5340              point, we want to move it to the reloc instead as that's
5341              where the dynamic linker wants it.  */
5342           rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + h->got.offset);
5343           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5344           if (h->dynindx == -1)
5345             rel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_TPOFF);
5346           else
5347             rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_TPOFF);
5348           break;
5349
5350         default:
5351           /* If this is a -Bsymbolic link, and the symbol is defined
5352              locally, we just want to emit a RELATIVE reloc.  Likewise if
5353              the symbol was forced to be local because of a version file.
5354              The entry in the global offset table will already have been
5355              initialized in the relocate_section function.  */
5356           if (bfd_link_pic (info)
5357               && (info->symbolic || h->dynindx == -1)
5358               && h->def_regular)
5359             {
5360               rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
5361               rel.r_addend = (h->root.u.def.value
5362                               + h->root.u.def.section->output_section->vma
5363                               + h->root.u.def.section->output_offset);
5364             }
5365           else
5366             {
5367               bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5368               rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
5369               rel.r_addend = 0;
5370             }
5371         }
5372
5373       if (ELF32_R_TYPE (rel.r_info) != R_MN10300_NONE)
5374         {
5375           bfd_elf32_swap_reloca_out (output_bfd, &rel,
5376                                      (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5377                                                    + srel->reloc_count));
5378           ++ srel->reloc_count;
5379         }
5380     }
5381
5382   if (h->needs_copy)
5383     {
5384       asection *        s;
5385       Elf_Internal_Rela rel;
5386
5387       /* This symbol needs a copy reloc.  Set it up.  */
5388       BFD_ASSERT (h->dynindx != -1
5389                   && (h->root.type == bfd_link_hash_defined
5390                       || h->root.type == bfd_link_hash_defweak));
5391
5392       s = bfd_get_linker_section (dynobj, ".rela.bss");
5393       BFD_ASSERT (s != NULL);
5394
5395       rel.r_offset = (h->root.u.def.value
5396                       + h->root.u.def.section->output_section->vma
5397                       + h->root.u.def.section->output_offset);
5398       rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
5399       rel.r_addend = 0;
5400       bfd_elf32_swap_reloca_out (output_bfd, & rel,
5401                                  (bfd_byte *) ((Elf32_External_Rela *) s->contents
5402                                                + s->reloc_count));
5403       ++ s->reloc_count;
5404     }
5405
5406   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5407   if (h == elf_hash_table (info)->hdynamic
5408       || h == elf_hash_table (info)->hgot)
5409     sym->st_shndx = SHN_ABS;
5410
5411   return TRUE;
5412 }
5413
5414 /* Finish up the dynamic sections.  */
5415
5416 static bfd_boolean
5417 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
5418                                           struct bfd_link_info * info)
5419 {
5420   bfd *      dynobj;
5421   asection * sgot;
5422   asection * sdyn;
5423   struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
5424
5425   dynobj = htab->root.dynobj;
5426   sgot = htab->root.sgotplt;
5427   BFD_ASSERT (sgot != NULL);
5428   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5429
5430   if (elf_hash_table (info)->dynamic_sections_created)
5431     {
5432       asection *           splt;
5433       Elf32_External_Dyn * dyncon;
5434       Elf32_External_Dyn * dynconend;
5435
5436       BFD_ASSERT (sdyn != NULL);
5437
5438       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5439       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5440
5441       for (; dyncon < dynconend; dyncon++)
5442         {
5443           Elf_Internal_Dyn dyn;
5444           const char * name;
5445           asection * s;
5446
5447           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5448
5449           switch (dyn.d_tag)
5450             {
5451             default:
5452               break;
5453
5454             case DT_PLTGOT:
5455               name = ".got";
5456               goto get_vma;
5457
5458             case DT_JMPREL:
5459               name = ".rela.plt";
5460             get_vma:
5461               s = bfd_get_linker_section (dynobj, name);
5462               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5463               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5464               break;
5465
5466             case DT_PLTRELSZ:
5467               s = bfd_get_linker_section (dynobj, ".rela.plt");
5468               dyn.d_un.d_val = s->size;
5469               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5470               break;
5471
5472             case DT_RELASZ:
5473               /* My reading of the SVR4 ABI indicates that the
5474                  procedure linkage table relocs (DT_JMPREL) should be
5475                  included in the overall relocs (DT_RELA).  This is
5476                  what Solaris does.  However, UnixWare can not handle
5477                  that case.  Therefore, we override the DT_RELASZ entry
5478                  here to make it not include the JMPREL relocs.  Since
5479                  the linker script arranges for .rela.plt to follow all
5480                  other relocation sections, we don't have to worry
5481                  about changing the DT_RELA entry.  */
5482               s = bfd_get_linker_section (dynobj, ".rela.plt");
5483               if (s != NULL)
5484                 dyn.d_un.d_val -= s->size;
5485               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5486               break;
5487             }
5488         }
5489
5490       /* Fill in the first entry in the procedure linkage table.  */
5491       splt = htab->root.splt;
5492       if (splt && splt->size > 0)
5493         {
5494           if (bfd_link_pic (info))
5495             {
5496               memcpy (splt->contents, elf_mn10300_pic_plt_entry,
5497                       elf_mn10300_sizeof_plt (info));
5498             }
5499           else
5500             {
5501               memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
5502               bfd_put_32 (output_bfd,
5503                           sgot->output_section->vma + sgot->output_offset + 4,
5504                           splt->contents + elf_mn10300_plt0_gotid_offset (info));
5505               bfd_put_32 (output_bfd,
5506                           sgot->output_section->vma + sgot->output_offset + 8,
5507                           splt->contents + elf_mn10300_plt0_linker_offset (info));
5508             }
5509
5510           /* UnixWare sets the entsize of .plt to 4, although that doesn't
5511              really seem like the right value.  */
5512           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
5513
5514           /* UnixWare sets the entsize of .plt to 4, but this is incorrect
5515              as it means that the size of the PLT0 section (15 bytes) is not
5516              a multiple of the sh_entsize.  Some ELF tools flag this as an
5517              error.  We could pad PLT0 to 16 bytes, but that would introduce
5518              compatibilty issues with previous toolchains, so instead we
5519              just set the entry size to 1.  */
5520           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 1;
5521         }
5522     }
5523
5524   /* Fill in the first three entries in the global offset table.  */
5525   if (sgot->size > 0)
5526     {
5527       if (sdyn == NULL)
5528         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5529       else
5530         bfd_put_32 (output_bfd,
5531                     sdyn->output_section->vma + sdyn->output_offset,
5532                     sgot->contents);
5533       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5534       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5535     }
5536
5537   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5538
5539   return TRUE;
5540 }
5541
5542 /* Classify relocation types, such that combreloc can sort them
5543    properly.  */
5544
5545 static enum elf_reloc_type_class
5546 _bfd_mn10300_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5547                                    const asection *rel_sec ATTRIBUTE_UNUSED,
5548                                    const Elf_Internal_Rela *rela)
5549 {
5550   switch ((int) ELF32_R_TYPE (rela->r_info))
5551     {
5552     case R_MN10300_RELATIVE:    return reloc_class_relative;
5553     case R_MN10300_JMP_SLOT:    return reloc_class_plt;
5554     case R_MN10300_COPY:        return reloc_class_copy;
5555     default:                    return reloc_class_normal;
5556     }
5557 }
5558
5559 /* Allocate space for an MN10300 extension to the bfd elf data structure.  */
5560
5561 static bfd_boolean
5562 mn10300_elf_mkobject (bfd *abfd)
5563 {
5564   return bfd_elf_allocate_object (abfd, sizeof (struct elf_mn10300_obj_tdata),
5565                                   MN10300_ELF_DATA);
5566 }
5567
5568 #define bfd_elf32_mkobject      mn10300_elf_mkobject
5569
5570 #ifndef ELF_ARCH
5571 #define TARGET_LITTLE_SYM       mn10300_elf32_vec
5572 #define TARGET_LITTLE_NAME      "elf32-mn10300"
5573 #define ELF_ARCH                bfd_arch_mn10300
5574 #define ELF_TARGET_ID           MN10300_ELF_DATA
5575 #define ELF_MACHINE_CODE        EM_MN10300
5576 #define ELF_MACHINE_ALT1        EM_CYGNUS_MN10300
5577 #define ELF_MAXPAGESIZE         0x1000
5578 #endif
5579
5580 #define elf_info_to_howto               mn10300_info_to_howto
5581 #define elf_info_to_howto_rel           0
5582 #define elf_backend_can_gc_sections     1
5583 #define elf_backend_rela_normal         1
5584 #define elf_backend_check_relocs        mn10300_elf_check_relocs
5585 #define elf_backend_gc_mark_hook        mn10300_elf_gc_mark_hook
5586 #define elf_backend_relocate_section    mn10300_elf_relocate_section
5587 #define bfd_elf32_bfd_relax_section     mn10300_elf_relax_section
5588 #define bfd_elf32_bfd_get_relocated_section_contents \
5589                                 mn10300_elf_get_relocated_section_contents
5590 #define bfd_elf32_bfd_link_hash_table_create \
5591                                 elf32_mn10300_link_hash_table_create
5592
5593 #ifndef elf_symbol_leading_char
5594 #define elf_symbol_leading_char '_'
5595 #endif
5596
5597 /* So we can set bits in e_flags.  */
5598 #define elf_backend_final_write_processing \
5599                                         _bfd_mn10300_elf_final_write_processing
5600 #define elf_backend_object_p            _bfd_mn10300_elf_object_p
5601
5602 #define bfd_elf32_bfd_merge_private_bfd_data \
5603                                         _bfd_mn10300_elf_merge_private_bfd_data
5604
5605 #define elf_backend_can_gc_sections     1
5606 #define elf_backend_create_dynamic_sections \
5607   _bfd_mn10300_elf_create_dynamic_sections
5608 #define elf_backend_adjust_dynamic_symbol \
5609   _bfd_mn10300_elf_adjust_dynamic_symbol
5610 #define elf_backend_size_dynamic_sections \
5611   _bfd_mn10300_elf_size_dynamic_sections
5612 #define elf_backend_omit_section_dynsym \
5613   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5614 #define elf_backend_finish_dynamic_symbol \
5615   _bfd_mn10300_elf_finish_dynamic_symbol
5616 #define elf_backend_finish_dynamic_sections \
5617   _bfd_mn10300_elf_finish_dynamic_sections
5618 #define elf_backend_copy_indirect_symbol \
5619   _bfd_mn10300_copy_indirect_symbol
5620 #define elf_backend_reloc_type_class \
5621   _bfd_mn10300_elf_reloc_type_class
5622
5623 #define elf_backend_want_got_plt        1
5624 #define elf_backend_plt_readonly        1
5625 #define elf_backend_want_plt_sym        0
5626 #define elf_backend_got_header_size     12
5627
5628 #include "elf32-target.h"