bfd/elf-m10300.c

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