bfd/elf64-sh64.c

   1 /* SuperH SH64-specific support for 64-bit ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   3    2010  Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #define SH64_ELF64
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "bfdlink.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29 #include "elf/sh.h"
  30
  31 /* Add a suffix for datalabel indirection symbols.  It must not match any
  32    other symbols; user symbols with or without version or other
  33    decoration.  It must only be used internally and not emitted by any
  34    means.  */
  35 #define DATALABEL_SUFFIX " DL"
  36
  37 #define GOT_BIAS (-((long)-32768))
  38
  39 #define PLT_ENTRY_SIZE 64
  40
  41 /* Return size of a PLT entry.  */
  42 #define elf_sh64_sizeof_plt(info) PLT_ENTRY_SIZE
  43
  44 /* Return offset of the PLT0 address in an absolute PLT entry.  */
  45 #define elf_sh64_plt_plt0_offset(info) 32
  46
  47 /* Return offset of the linker in PLT0 entry.  */
  48 #define elf_sh64_plt0_gotplt_offset(info) 0
  49
  50 /* Return offset of the trampoline in PLT entry */
  51 #define elf_sh64_plt_temp_offset(info) 33 /* Add one because it's SHmedia.  */
  52
  53 /* Return offset of the symbol in PLT entry.  */
  54 #define elf_sh64_plt_symbol_offset(info) 0
  55
  56 /* Return offset of the relocation in PLT entry.  */
  57 #define elf_sh64_plt_reloc_offset(info) (info->shared ? 52 : 44)
  58
  59 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
  60
  61 /* The sh linker needs to keep track of the number of relocs that it
  62    decides to copy in check_relocs for each symbol.  This is so that
  63    it can discard PC relative relocs if it doesn't need them when
  64    linking with -Bsymbolic.  We store the information in a field
  65    extending the regular ELF linker hash table.  */
  66
  67 /* This structure keeps track of the number of PC relative relocs we
  68    have copied for a given symbol.  */
  69
  70 struct elf_sh64_pcrel_relocs_copied
  71 {
  72   /* Next section.  */
  73   struct elf_sh64_pcrel_relocs_copied *next;
  74   /* A section in dynobj.  */
  75   asection *section;
  76   /* Number of relocs copied in this section.  */
  77   bfd_size_type count;
  78 };
  79
  80 /* sh ELF linker hash entry.  */
  81
  82 struct elf_sh64_link_hash_entry
  83 {
  84   struct elf_link_hash_entry root;
  85
  86   bfd_vma datalabel_got_offset;
  87
  88   /* Number of PC relative relocs copied for this symbol.  */
  89   struct elf_sh64_pcrel_relocs_copied *pcrel_relocs_copied;
  90 };
  91
  92 /* Traverse an sh ELF linker hash table.  */
  93
  94 #define sh64_elf64_link_hash_traverse(table, func, info)        \
  95   (elf_link_hash_traverse                                       \
  96    ((table),                                                    \
  97     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
  98     (info)))
  99
 100 static bfd_reloc_status_type sh_elf64_ignore_reloc
 101   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 102 static bfd_reloc_status_type sh_elf64_reloc
 103   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 104
 105 static reloc_howto_type sh_elf64_howto_table[] = {
 106   /* No relocation.  */
 107   HOWTO (R_SH_NONE,             /* type */
 108          0,                     /* rightshift */
 109          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 110          0,                     /* bitsize */
 111          FALSE,                 /* pc_relative */
 112          0,                     /* bitpos */
 113          complain_overflow_dont, /* complain_on_overflow */
 114          sh_elf64_ignore_reloc, /* special_function */
 115          "R_SH_NONE",           /* name */
 116          FALSE,                 /* partial_inplace */
 117          0,                     /* src_mask */
 118          0,                     /* dst_mask */
 119          FALSE),                /* pcrel_offset */
 120
 121   /* 32 bit absolute relocation.  Setting partial_inplace to TRUE and
 122      src_mask to a non-zero value is similar to the COFF toolchain.  */
 123   HOWTO (R_SH_DIR32,            /* type */
 124          0,                     /* rightshift */
 125          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 126          32,                    /* bitsize */
 127          FALSE,                 /* pc_relative */
 128          0,                     /* bitpos */
 129          complain_overflow_bitfield, /* complain_on_overflow */
 130          sh_elf64_reloc,                /* special_function */
 131          "R_SH_DIR32",          /* name */
 132          TRUE,                  /* partial_inplace */
 133          0xffffffff,            /* src_mask */
 134          0xffffffff,            /* dst_mask */
 135          FALSE),                /* pcrel_offset */
 136
 137   /* 32 bit PC relative relocation.  */
 138   HOWTO (R_SH_REL32,            /* type */
 139          0,                     /* rightshift */
 140          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 141          32,                    /* bitsize */
 142          TRUE,                  /* pc_relative */
 143          0,                     /* bitpos */
 144          complain_overflow_signed, /* complain_on_overflow */
 145          sh_elf64_ignore_reloc, /* special_function */
 146          "R_SH_REL32",          /* name */
 147          FALSE,                 /* partial_inplace */
 148          0,                     /* src_mask */
 149          0xffffffff,            /* dst_mask */
 150          TRUE),                 /* pcrel_offset */
 151
 152   /* For 32-bit sh, this is R_SH_DIR8WPN.  */
 153   EMPTY_HOWTO (3),
 154
 155   /* For 32-bit sh, this is R_SH_IND12W.  */
 156   EMPTY_HOWTO (4),
 157
 158   /* For 32-bit sh, this is R_SH_DIR8WPL.  */
 159   EMPTY_HOWTO (5),
 160
 161   /* For 32-bit sh, this is R_SH_DIR8WPZ.  */
 162   EMPTY_HOWTO (6),
 163
 164   /* For 32-bit sh, this is R_SH_DIR8BP.  */
 165   EMPTY_HOWTO (7),
 166
 167   /* For 32-bit sh, this is R_SH_DIR8W.  */
 168   EMPTY_HOWTO (8),
 169
 170   /* For 32-bit sh, this is R_SH_DIR8L.  */
 171   EMPTY_HOWTO (9),
 172
 173   EMPTY_HOWTO (10),
 174   EMPTY_HOWTO (11),
 175   EMPTY_HOWTO (12),
 176   EMPTY_HOWTO (13),
 177   EMPTY_HOWTO (14),
 178   EMPTY_HOWTO (15),
 179   EMPTY_HOWTO (16),
 180   EMPTY_HOWTO (17),
 181   EMPTY_HOWTO (18),
 182   EMPTY_HOWTO (19),
 183   EMPTY_HOWTO (20),
 184   EMPTY_HOWTO (21),
 185   EMPTY_HOWTO (22),
 186   EMPTY_HOWTO (23),
 187   EMPTY_HOWTO (24),
 188
 189   /* The remaining relocs are a GNU extension used for relaxing.  The
 190      final pass of the linker never needs to do anything with any of
 191      these relocs.  Any required operations are handled by the
 192      relaxation code.  */
 193
 194   /* A 16 bit switch table entry.  This is generated for an expression
 195      such as ``.word L1 - L2''.  The offset holds the difference
 196      between the reloc address and L2.  */
 197   HOWTO (R_SH_SWITCH16,         /* type */
 198          0,                     /* rightshift */
 199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 200          16,                    /* bitsize */
 201          FALSE,                 /* pc_relative */
 202          0,                     /* bitpos */
 203          complain_overflow_unsigned, /* complain_on_overflow */
 204          sh_elf64_ignore_reloc, /* special_function */
 205          "R_SH_SWITCH16",       /* name */
 206          FALSE,                 /* partial_inplace */
 207          0,                     /* src_mask */
 208          0,                     /* dst_mask */
 209          TRUE),                 /* pcrel_offset */
 210
 211   /* A 32 bit switch table entry.  This is generated for an expression
 212      such as ``.long L1 - L2''.  The offset holds the difference
 213      between the reloc address and L2.  */
 214   HOWTO (R_SH_SWITCH32,         /* type */
 215          0,                     /* rightshift */
 216          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 217          32,                    /* bitsize */
 218          FALSE,                 /* pc_relative */
 219          0,                     /* bitpos */
 220          complain_overflow_unsigned, /* complain_on_overflow */
 221          sh_elf64_ignore_reloc, /* special_function */
 222          "R_SH_SWITCH32",       /* name */
 223          FALSE,                 /* partial_inplace */
 224          0,                     /* src_mask */
 225          0,                     /* dst_mask */
 226          TRUE),                 /* pcrel_offset */
 227
 228   /* For 32-bit sh, this is R_SH_USES.  */
 229   EMPTY_HOWTO (27),
 230
 231   /* For 32-bit sh, this is R_SH_COUNT.  */
 232   EMPTY_HOWTO (28),
 233
 234   /* For 32-bit sh, this is R_SH_ALIGN.  FIXME: For linker relaxation,
 235      this might be emitted.  When linker relaxation is implemented, we
 236      might want to use it.  */
 237   EMPTY_HOWTO (29),
 238
 239   /* For 32-bit sh, this is R_SH_CODE.  FIXME: For linker relaxation,
 240      this might be emitted.  When linker relaxation is implemented, we
 241      might want to use it.  */
 242   EMPTY_HOWTO (30),
 243
 244   /* For 32-bit sh, this is R_SH_DATA.  FIXME: For linker relaxation,
 245      this might be emitted.  When linker relaxation is implemented, we
 246      might want to use it.  */
 247   EMPTY_HOWTO (31),
 248
 249   /* For 32-bit sh, this is R_SH_LABEL.  FIXME: For linker relaxation,
 250      this might be emitted.  When linker relaxation is implemented, we
 251      might want to use it.  */
 252   EMPTY_HOWTO (32),
 253
 254   /* An 8 bit switch table entry.  This is generated for an expression
 255      such as ``.word L1 - L2''.  The offset holds the difference
 256      between the reloc address and L2.  */
 257   HOWTO (R_SH_SWITCH8,          /* type */
 258          0,                     /* rightshift */
 259          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 260          8,                     /* bitsize */
 261          FALSE,                 /* pc_relative */
 262          0,                     /* bitpos */
 263          complain_overflow_unsigned, /* complain_on_overflow */
 264          sh_elf64_ignore_reloc, /* special_function */
 265          "R_SH_SWITCH8",        /* name */
 266          FALSE,                 /* partial_inplace */
 267          0,                     /* src_mask */
 268          0,                     /* dst_mask */
 269          TRUE),                 /* pcrel_offset */
 270
 271   /* GNU extension to record C++ vtable hierarchy */
 272   HOWTO (R_SH_GNU_VTINHERIT, /* type */
 273          0,                     /* rightshift */
 274          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 275          0,                     /* bitsize */
 276          FALSE,                 /* pc_relative */
 277          0,                     /* bitpos */
 278          complain_overflow_dont, /* complain_on_overflow */
 279          NULL,                  /* special_function */
 280          "R_SH_GNU_VTINHERIT", /* name */
 281          FALSE,                 /* partial_inplace */
 282          0,                     /* src_mask */
 283          0,                     /* dst_mask */
 284          FALSE),                /* pcrel_offset */
 285
 286   /* GNU extension to record C++ vtable member usage */
 287   HOWTO (R_SH_GNU_VTENTRY,     /* type */
 288          0,                     /* rightshift */
 289          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 290          0,                     /* bitsize */
 291          FALSE,                 /* pc_relative */
 292          0,                     /* bitpos */
 293          complain_overflow_dont, /* complain_on_overflow */
 294          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 295          "R_SH_GNU_VTENTRY",   /* name */
 296          FALSE,                 /* partial_inplace */
 297          0,                     /* src_mask */
 298          0,                     /* dst_mask */
 299          FALSE),                /* pcrel_offset */
 300
 301   /* For 32-bit sh, this is R_SH_LOOP_START.  */
 302   EMPTY_HOWTO (36),
 303
 304   /* For 32-bit sh, this is R_SH_LOOP_END.  */
 305   EMPTY_HOWTO (37),
 306
 307   EMPTY_HOWTO (38),
 308   EMPTY_HOWTO (39),
 309   EMPTY_HOWTO (40),
 310   EMPTY_HOWTO (41),
 311   EMPTY_HOWTO (42),
 312   EMPTY_HOWTO (43),
 313   EMPTY_HOWTO (44),
 314
 315   /* Used in SHLLI.L and SHLRI.L.  */
 316   HOWTO (R_SH_DIR5U,            /* type */
 317          0,                     /* rightshift */
 318          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 319          5,                     /* bitsize */
 320          FALSE,                 /* pc_relative */
 321          10,                    /* bitpos */
 322          complain_overflow_unsigned, /* complain_on_overflow */
 323          bfd_elf_generic_reloc, /* special_function */
 324          "R_SH_DIR5U",          /* name */
 325          FALSE,                 /* partial_inplace */
 326          0,                     /* src_mask */
 327          0xfc00,                /* dst_mask */
 328          FALSE),                /* pcrel_offset */
 329
 330   /* Used in SHARI, SHLLI et al.  */
 331   HOWTO (R_SH_DIR6U,            /* type */
 332          0,                     /* rightshift */
 333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 334          6,                     /* bitsize */
 335          FALSE,                 /* pc_relative */
 336          10,                    /* bitpos */
 337          complain_overflow_unsigned, /* complain_on_overflow */
 338          bfd_elf_generic_reloc, /* special_function */
 339          "R_SH_DIR6U",          /* name */
 340          FALSE,                 /* partial_inplace */
 341          0,                     /* src_mask */
 342          0xfc00,                /* dst_mask */
 343          FALSE),                /* pcrel_offset */
 344
 345   /* Used in BxxI, LDHI.L et al.  */
 346   HOWTO (R_SH_DIR6S,            /* type */
 347          0,                     /* rightshift */
 348          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 349          6,                     /* bitsize */
 350          FALSE,                 /* pc_relative */
 351          10,                    /* bitpos */
 352          complain_overflow_signed, /* complain_on_overflow */
 353          bfd_elf_generic_reloc, /* special_function */
 354          "R_SH_DIR6S",          /* name */
 355          FALSE,                 /* partial_inplace */
 356          0,                     /* src_mask */
 357          0xfc00,                /* dst_mask */
 358          FALSE),                /* pcrel_offset */
 359
 360   /* Used in ADDI, ANDI et al.  */
 361   HOWTO (R_SH_DIR10S,           /* type */
 362          0,                     /* rightshift */
 363          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          10,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          10,                    /* bitpos */
 367          complain_overflow_signed, /* complain_on_overflow */
 368          bfd_elf_generic_reloc, /* special_function */
 369          "R_SH_DIR10S",         /* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0xffc00,               /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* Used in LD.UW, ST.W et al.  */
 376   HOWTO (R_SH_DIR10SW,  /* type */
 377          1,                     /* rightshift */
 378          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 379          11,                    /* bitsize */
 380          FALSE,                 /* pc_relative */
 381          10,                    /* bitpos */
 382          complain_overflow_signed, /* complain_on_overflow */
 383          bfd_elf_generic_reloc, /* special_function */
 384          "R_SH_DIR10SW",        /* name */
 385          FALSE,                 /* partial_inplace */
 386          0,                     /* src_mask */
 387          0xffc00,               /* dst_mask */
 388          FALSE),                /* pcrel_offset */
 389
 390   /* Used in LD.L, FLD.S et al.  */
 391   HOWTO (R_SH_DIR10SL,  /* type */
 392          2,                     /* rightshift */
 393          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 394          12,                    /* bitsize */
 395          FALSE,                 /* pc_relative */
 396          10,                    /* bitpos */
 397          complain_overflow_signed, /* complain_on_overflow */
 398          bfd_elf_generic_reloc, /* special_function */
 399          "R_SH_DIR10SL",        /* name */
 400          FALSE,                 /* partial_inplace */
 401          0,                     /* src_mask */
 402          0xffc00,               /* dst_mask */
 403          FALSE),                /* pcrel_offset */
 404
 405   /* Used in FLD.D, FST.P et al.  */
 406   HOWTO (R_SH_DIR10SQ,  /* type */
 407          3,                     /* rightshift */
 408          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 409          13,                    /* bitsize */
 410          FALSE,                 /* pc_relative */
 411          10,                    /* bitpos */
 412          complain_overflow_signed, /* complain_on_overflow */
 413          bfd_elf_generic_reloc, /* special_function */
 414          "R_SH_DIR10SQ",        /* name */
 415          FALSE,                 /* partial_inplace */
 416          0,                     /* src_mask */
 417          0xffc00,               /* dst_mask */
 418          FALSE),                /* pcrel_offset */
 419
 420   EMPTY_HOWTO (52),
 421   EMPTY_HOWTO (53),
 422   EMPTY_HOWTO (54),
 423   EMPTY_HOWTO (55),
 424   EMPTY_HOWTO (56),
 425   EMPTY_HOWTO (57),
 426   EMPTY_HOWTO (58),
 427   EMPTY_HOWTO (59),
 428   EMPTY_HOWTO (60),
 429   EMPTY_HOWTO (61),
 430   EMPTY_HOWTO (62),
 431   EMPTY_HOWTO (63),
 432   EMPTY_HOWTO (64),
 433   EMPTY_HOWTO (65),
 434   EMPTY_HOWTO (66),
 435   EMPTY_HOWTO (67),
 436   EMPTY_HOWTO (68),
 437   EMPTY_HOWTO (69),
 438   EMPTY_HOWTO (70),
 439   EMPTY_HOWTO (71),
 440   EMPTY_HOWTO (72),
 441   EMPTY_HOWTO (73),
 442   EMPTY_HOWTO (74),
 443   EMPTY_HOWTO (75),
 444   EMPTY_HOWTO (76),
 445   EMPTY_HOWTO (77),
 446   EMPTY_HOWTO (78),
 447   EMPTY_HOWTO (79),
 448   EMPTY_HOWTO (80),
 449   EMPTY_HOWTO (81),
 450   EMPTY_HOWTO (82),
 451   EMPTY_HOWTO (83),
 452   EMPTY_HOWTO (84),
 453   EMPTY_HOWTO (85),
 454   EMPTY_HOWTO (86),
 455   EMPTY_HOWTO (87),
 456   EMPTY_HOWTO (88),
 457   EMPTY_HOWTO (89),
 458   EMPTY_HOWTO (90),
 459   EMPTY_HOWTO (91),
 460   EMPTY_HOWTO (92),
 461   EMPTY_HOWTO (93),
 462   EMPTY_HOWTO (94),
 463   EMPTY_HOWTO (95),
 464   EMPTY_HOWTO (96),
 465   EMPTY_HOWTO (97),
 466   EMPTY_HOWTO (98),
 467   EMPTY_HOWTO (99),
 468   EMPTY_HOWTO (100),
 469   EMPTY_HOWTO (101),
 470   EMPTY_HOWTO (102),
 471   EMPTY_HOWTO (103),
 472   EMPTY_HOWTO (104),
 473   EMPTY_HOWTO (105),
 474   EMPTY_HOWTO (106),
 475   EMPTY_HOWTO (107),
 476   EMPTY_HOWTO (108),
 477   EMPTY_HOWTO (109),
 478   EMPTY_HOWTO (110),
 479   EMPTY_HOWTO (111),
 480   EMPTY_HOWTO (112),
 481   EMPTY_HOWTO (113),
 482   EMPTY_HOWTO (114),
 483   EMPTY_HOWTO (115),
 484   EMPTY_HOWTO (116),
 485   EMPTY_HOWTO (117),
 486   EMPTY_HOWTO (118),
 487   EMPTY_HOWTO (119),
 488   EMPTY_HOWTO (120),
 489   EMPTY_HOWTO (121),
 490   EMPTY_HOWTO (122),
 491   EMPTY_HOWTO (123),
 492   EMPTY_HOWTO (124),
 493   EMPTY_HOWTO (125),
 494   EMPTY_HOWTO (126),
 495   EMPTY_HOWTO (127),
 496   EMPTY_HOWTO (128),
 497   EMPTY_HOWTO (129),
 498   EMPTY_HOWTO (130),
 499   EMPTY_HOWTO (131),
 500   EMPTY_HOWTO (132),
 501   EMPTY_HOWTO (133),
 502   EMPTY_HOWTO (134),
 503   EMPTY_HOWTO (135),
 504   EMPTY_HOWTO (136),
 505   EMPTY_HOWTO (137),
 506   EMPTY_HOWTO (138),
 507   EMPTY_HOWTO (139),
 508   EMPTY_HOWTO (140),
 509   EMPTY_HOWTO (141),
 510   EMPTY_HOWTO (142),
 511   EMPTY_HOWTO (143),
 512   EMPTY_HOWTO (144),
 513   EMPTY_HOWTO (145),
 514   EMPTY_HOWTO (146),
 515   EMPTY_HOWTO (147),
 516   EMPTY_HOWTO (148),
 517   EMPTY_HOWTO (149),
 518   EMPTY_HOWTO (150),
 519   EMPTY_HOWTO (151),
 520   EMPTY_HOWTO (152),
 521   EMPTY_HOWTO (153),
 522   EMPTY_HOWTO (154),
 523   EMPTY_HOWTO (155),
 524   EMPTY_HOWTO (156),
 525   EMPTY_HOWTO (157),
 526   EMPTY_HOWTO (158),
 527   EMPTY_HOWTO (159),
 528
 529   /* Relocs for dynamic linking for 32-bit SH would follow.  We don't have
 530      any dynamic linking support for 64-bit SH at present.  */
 531
 532   EMPTY_HOWTO (160),
 533   EMPTY_HOWTO (161),
 534   EMPTY_HOWTO (162),
 535   EMPTY_HOWTO (163),
 536   EMPTY_HOWTO (164),
 537   EMPTY_HOWTO (165),
 538   EMPTY_HOWTO (166),
 539   EMPTY_HOWTO (167),
 540   EMPTY_HOWTO (168),
 541
 542   /* Back to SH5 relocations.  */
 543   /* Used in MOVI and SHORI (x & 65536).  */
 544   HOWTO (R_SH_GOT_LOW16,        /* type */
 545          0,                     /* rightshift */
 546          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 547          64,                    /* bitsize */
 548          FALSE,                 /* pc_relative */
 549          10,                    /* bitpos */
 550          complain_overflow_dont, /* complain_on_overflow */
 551          bfd_elf_generic_reloc, /* special_function */
 552          "R_SH_GOT_LOW16",      /* name */
 553          FALSE,                 /* partial_inplace */
 554          0,                     /* src_mask */
 555          0x3fffc00,             /* dst_mask */
 556          FALSE),                /* pcrel_offset */
 557
 558   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
 559   HOWTO (R_SH_GOT_MEDLOW16,     /* type */
 560          16,                    /* rightshift */
 561          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 562          64,                    /* bitsize */
 563          FALSE,                 /* pc_relative */
 564          10,                    /* bitpos */
 565          complain_overflow_dont, /* complain_on_overflow */
 566          bfd_elf_generic_reloc, /* special_function */
 567          "R_SH_GOT_MEDLOW16",   /* name */
 568          FALSE,                 /* partial_inplace */
 569          0,                     /* src_mask */
 570          0x3fffc00,             /* dst_mask */
 571          FALSE),                /* pcrel_offset */
 572
 573   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
 574   HOWTO (R_SH_GOT_MEDHI16,      /* type */
 575          32,                    /* rightshift */
 576          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 577          64,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          10,                    /* bitpos */
 580          complain_overflow_dont, /* complain_on_overflow */
 581          bfd_elf_generic_reloc, /* special_function */
 582          "R_SH_GOT_MEDHI16",    /* name */
 583          FALSE,                 /* partial_inplace */
 584          0,                     /* src_mask */
 585          0x3fffc00,             /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
 589   HOWTO (R_SH_GOT_HI16,         /* type */
 590          48,                    /* rightshift */
 591          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 592          64,                    /* bitsize */
 593          FALSE,                 /* pc_relative */
 594          10,                    /* bitpos */
 595          complain_overflow_dont, /* complain_on_overflow */
 596          bfd_elf_generic_reloc, /* special_function */
 597          "R_SH_GOT_HI16",       /* name */
 598          FALSE,                 /* partial_inplace */
 599          0,                     /* src_mask */
 600          0x3fffc00,             /* dst_mask */
 601          FALSE),                /* pcrel_offset */
 602
 603   /* Used in MOVI and SHORI (x & 65536).  */
 604   HOWTO (R_SH_GOTPLT_LOW16,     /* type */
 605          0,                     /* rightshift */
 606          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 607          64,                    /* bitsize */
 608          FALSE,                 /* pc_relative */
 609          10,                    /* bitpos */
 610          complain_overflow_dont, /* complain_on_overflow */
 611          bfd_elf_generic_reloc, /* special_function */
 612          "R_SH_GOTPLT_LOW16",   /* name */
 613          FALSE,                 /* partial_inplace */
 614          0,                     /* src_mask */
 615          0x3fffc00,             /* dst_mask */
 616          FALSE),                /* pcrel_offset */
 617
 618   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
 619   HOWTO (R_SH_GOTPLT_MEDLOW16,  /* type */
 620          16,                    /* rightshift */
 621          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 622          64,                    /* bitsize */
 623          FALSE,                 /* pc_relative */
 624          10,                    /* bitpos */
 625          complain_overflow_dont, /* complain_on_overflow */
 626          bfd_elf_generic_reloc, /* special_function */
 627          "R_SH_GOTPLT_MEDLOW16", /* name */
 628          FALSE,                 /* partial_inplace */
 629          0,                     /* src_mask */
 630          0x3fffc00,             /* dst_mask */
 631          FALSE),                /* pcrel_offset */
 632
 633   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
 634   HOWTO (R_SH_GOTPLT_MEDHI16,   /* type */
 635          32,                    /* rightshift */
 636          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          64,                    /* bitsize */
 638          FALSE,                 /* pc_relative */
 639          10,                    /* bitpos */
 640          complain_overflow_dont, /* complain_on_overflow */
 641          bfd_elf_generic_reloc, /* special_function */
 642          "R_SH_GOTPLT_MEDHI16", /* name */
 643          FALSE,                 /* partial_inplace */
 644          0,                     /* src_mask */
 645          0x3fffc00,             /* dst_mask */
 646          FALSE),                /* pcrel_offset */
 647
 648   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
 649   HOWTO (R_SH_GOTPLT_HI16,      /* type */
 650          48,                    /* rightshift */
 651          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 652          64,                    /* bitsize */
 653          FALSE,                 /* pc_relative */
 654          10,                    /* bitpos */
 655          complain_overflow_dont, /* complain_on_overflow */
 656          bfd_elf_generic_reloc, /* special_function */
 657          "R_SH_GOTPLT_HI16",    /* name */
 658          FALSE,                 /* partial_inplace */
 659          0,                     /* src_mask */
 660          0x3fffc00,             /* dst_mask */
 661          FALSE),                /* pcrel_offset */
 662
 663   /* Used in MOVI and SHORI (x & 65536).  */
 664   HOWTO (R_SH_PLT_LOW16,        /* type */
 665          0,                     /* rightshift */
 666          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 667          64,                    /* bitsize */
 668          TRUE,                  /* pc_relative */
 669          10,                    /* bitpos */
 670          complain_overflow_dont, /* complain_on_overflow */
 671          bfd_elf_generic_reloc, /* special_function */
 672          "R_SH_PLT_LOW16",      /* name */
 673          FALSE,                 /* partial_inplace */
 674          0,                     /* src_mask */
 675          0x3fffc00,             /* dst_mask */
 676          TRUE),                 /* pcrel_offset */
 677
 678   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
 679   HOWTO (R_SH_PLT_MEDLOW16,     /* type */
 680          16,                    /* rightshift */
 681          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 682          64,                    /* bitsize */
 683          TRUE,                  /* pc_relative */
 684          10,                    /* bitpos */
 685          complain_overflow_dont, /* complain_on_overflow */
 686          bfd_elf_generic_reloc, /* special_function */
 687          "R_SH_PLT_MEDLOW16",   /* name */
 688          FALSE,                 /* partial_inplace */
 689          0,                     /* src_mask */
 690          0x3fffc00,             /* dst_mask */
 691          TRUE),                 /* pcrel_offset */
 692
 693   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
 694   HOWTO (R_SH_PLT_MEDHI16,      /* type */
 695          32,                    /* rightshift */
 696          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 697          64,                    /* bitsize */
 698          TRUE,                  /* pc_relative */
 699          10,                    /* bitpos */
 700          complain_overflow_dont, /* complain_on_overflow */
 701          bfd_elf_generic_reloc, /* special_function */
 702          "R_SH_PLT_MEDHI16",    /* name */
 703          FALSE,                 /* partial_inplace */
 704          0,                     /* src_mask */
 705          0x3fffc00,             /* dst_mask */
 706          TRUE),                 /* pcrel_offset */
 707
 708   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
 709   HOWTO (R_SH_PLT_HI16,         /* type */
 710          48,                    /* rightshift */
 711          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 712          64,                    /* bitsize */
 713          TRUE,                  /* pc_relative */
 714          10,                    /* bitpos */
 715          complain_overflow_dont, /* complain_on_overflow */
 716          bfd_elf_generic_reloc, /* special_function */
 717          "R_SH_PLT_HI16",       /* name */
 718          FALSE,                 /* partial_inplace */
 719          0,                     /* src_mask */
 720          0x3fffc00,             /* dst_mask */
 721          TRUE),                 /* pcrel_offset */
 722
 723   /* Used in MOVI and SHORI (x & 65536).  */
 724   HOWTO (R_SH_GOTOFF_LOW16,     /* type */
 725          0,                     /* rightshift */
 726          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 727          64,                    /* bitsize */
 728          FALSE,                 /* pc_relative */
 729          10,                    /* bitpos */
 730          complain_overflow_dont, /* complain_on_overflow */
 731          bfd_elf_generic_reloc, /* special_function */
 732          "R_SH_GOTOFF_LOW16",   /* name */
 733          FALSE,                 /* partial_inplace */
 734          0,                     /* src_mask */
 735          0x3fffc00,             /* dst_mask */
 736          FALSE),                /* pcrel_offset */
 737
 738   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
 739   HOWTO (R_SH_GOTOFF_MEDLOW16,  /* type */
 740          16,                    /* rightshift */
 741          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 742          64,                    /* bitsize */
 743          FALSE,                 /* pc_relative */
 744          10,                    /* bitpos */
 745          complain_overflow_dont, /* complain_on_overflow */
 746          bfd_elf_generic_reloc, /* special_function */
 747          "R_SH_GOTOFF_MEDLOW16", /* name */
 748          FALSE,                 /* partial_inplace */
 749          0,                     /* src_mask */
 750          0x3fffc00,             /* dst_mask */
 751          FALSE),                /* pcrel_offset */
 752
 753   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
 754   HOWTO (R_SH_GOTOFF_MEDHI16,   /* type */
 755          32,                    /* rightshift */
 756          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 757          64,                    /* bitsize */
 758          FALSE,                 /* pc_relative */
 759          10,                    /* bitpos */
 760          complain_overflow_dont, /* complain_on_overflow */
 761          bfd_elf_generic_reloc, /* special_function */
 762          "R_SH_GOTOFF_MEDHI16", /* name */
 763          FALSE,                 /* partial_inplace */
 764          0,                     /* src_mask */
 765          0x3fffc00,             /* dst_mask */
 766          FALSE),                /* pcrel_offset */
 767
 768   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
 769   HOWTO (R_SH_GOTOFF_HI16,      /* type */
 770          48,                    /* rightshift */
 771          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 772          64,                    /* bitsize */
 773          FALSE,                 /* pc_relative */
 774          10,                    /* bitpos */
 775          complain_overflow_dont, /* complain_on_overflow */
 776          bfd_elf_generic_reloc, /* special_function */
 777          "R_SH_GOTOFF_HI16",    /* name */
 778          FALSE,                 /* partial_inplace */
 779          0,                     /* src_mask */
 780          0x3fffc00,             /* dst_mask */
 781          FALSE),                /* pcrel_offset */
 782
 783   /* Used in MOVI and SHORI (x & 65536).  */
 784   HOWTO (R_SH_GOTPC_LOW16,      /* type */
 785          0,                     /* rightshift */
 786          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 787          64,                    /* bitsize */
 788          TRUE,                  /* pc_relative */
 789          10,                    /* bitpos */
 790          complain_overflow_dont, /* complain_on_overflow */
 791          bfd_elf_generic_reloc, /* special_function */
 792          "R_SH_GOTPC_LOW16",    /* name */
 793          FALSE,                 /* partial_inplace */
 794          0,                     /* src_mask */
 795          0x3fffc00,             /* dst_mask */
 796          TRUE),                 /* pcrel_offset */
 797
 798   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
 799   HOWTO (R_SH_GOTPC_MEDLOW16,   /* type */
 800          16,                    /* rightshift */
 801          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 802          64,                    /* bitsize */
 803          TRUE,                  /* pc_relative */
 804          10,                    /* bitpos */
 805          complain_overflow_dont, /* complain_on_overflow */
 806          bfd_elf_generic_reloc, /* special_function */
 807          "R_SH_GOTPC_MEDLOW16", /* name */
 808          FALSE,                 /* partial_inplace */
 809          0,                     /* src_mask */
 810          0x3fffc00,             /* dst_mask */
 811          TRUE),                 /* pcrel_offset */
 812
 813   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
 814   HOWTO (R_SH_GOTPC_MEDHI16,    /* type */
 815          32,                    /* rightshift */
 816          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 817          64,                    /* bitsize */
 818          TRUE,                  /* pc_relative */
 819          10,                    /* bitpos */
 820          complain_overflow_dont, /* complain_on_overflow */
 821          bfd_elf_generic_reloc, /* special_function */
 822          "R_SH_GOTPC_MEDHI16",  /* name */
 823          FALSE,                 /* partial_inplace */
 824          0,                     /* src_mask */
 825          0x3fffc00,             /* dst_mask */
 826          TRUE),                 /* pcrel_offset */
 827
 828   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
 829   HOWTO (R_SH_GOTPC_HI16,       /* type */
 830          48,                    /* rightshift */
 831          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 832          64,                    /* bitsize */
 833          TRUE,                  /* pc_relative */
 834          10,                    /* bitpos */
 835          complain_overflow_dont, /* complain_on_overflow */
 836          bfd_elf_generic_reloc, /* special_function */
 837          "R_SH_GOTPC_HI16",     /* name */
 838          FALSE,                 /* partial_inplace */
 839          0,                     /* src_mask */
 840          0x3fffc00,             /* dst_mask */
 841          TRUE),                 /* pcrel_offset */
 842
 843   /* Used in LD.L, FLD.S et al.  */
 844   HOWTO (R_SH_GOT10BY4,         /* type */
 845          2,                     /* rightshift */
 846          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 847          12,                    /* bitsize */
 848          FALSE,                 /* pc_relative */
 849          10,                    /* bitpos */
 850          complain_overflow_signed, /* complain_on_overflow */
 851          bfd_elf_generic_reloc, /* special_function */
 852          "R_SH_GOT10BY4",       /* name */
 853          FALSE,                 /* partial_inplace */
 854          0,                     /* src_mask */
 855          0xffc00,               /* dst_mask */
 856          FALSE),                /* pcrel_offset */
 857
 858   /* Used in LD.L, FLD.S et al.  */
 859   HOWTO (R_SH_GOTPLT10BY4,      /* type */
 860          2,                     /* rightshift */
 861          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          12,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          10,                    /* bitpos */
 865          complain_overflow_signed, /* complain_on_overflow */
 866          bfd_elf_generic_reloc, /* special_function */
 867          "R_SH_GOTPLT10BY4",    /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffc00,               /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* Used in FLD.D, FST.P et al.  */
 874   HOWTO (R_SH_GOT10BY8,         /* type */
 875          3,                     /* rightshift */
 876          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 877          13,                    /* bitsize */
 878          FALSE,                 /* pc_relative */
 879          10,                    /* bitpos */
 880          complain_overflow_signed, /* complain_on_overflow */
 881          bfd_elf_generic_reloc, /* special_function */
 882          "R_SH_GOT10BY8",       /* name */
 883          FALSE,                 /* partial_inplace */
 884          0,                     /* src_mask */
 885          0xffc00,               /* dst_mask */
 886          FALSE),                /* pcrel_offset */
 887
 888   /* Used in FLD.D, FST.P et al.  */
 889   HOWTO (R_SH_GOTPLT10BY8,      /* type */
 890          3,                     /* rightshift */
 891          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 892          13,                    /* bitsize */
 893          FALSE,                 /* pc_relative */
 894          10,                    /* bitpos */
 895          complain_overflow_signed, /* complain_on_overflow */
 896          bfd_elf_generic_reloc, /* special_function */
 897          "R_SH_GOTPLT10BY8",    /* name */
 898          FALSE,                 /* partial_inplace */
 899          0,                     /* src_mask */
 900          0xffc00,               /* dst_mask */
 901          FALSE),                /* pcrel_offset */
 902
 903   HOWTO (R_SH_COPY64,           /* type */
 904          0,                     /* rightshift */
 905          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 906          64,                    /* bitsize */
 907          FALSE,                 /* pc_relative */
 908          0,                     /* bitpos */
 909          complain_overflow_dont, /* complain_on_overflow */
 910          bfd_elf_generic_reloc, /* special_function */
 911          "R_SH_COPY64",         /* name */
 912          FALSE,                 /* partial_inplace */
 913          0,                     /* src_mask */
 914          ((bfd_vma) 0) - 1,     /* dst_mask */
 915          FALSE),                /* pcrel_offset */
 916
 917   HOWTO (R_SH_GLOB_DAT64,       /* type */
 918          0,                     /* rightshift */
 919          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 920          64,                    /* bitsize */
 921          FALSE,                 /* pc_relative */
 922          0,                     /* bitpos */
 923          complain_overflow_dont, /* complain_on_overflow */
 924          bfd_elf_generic_reloc, /* special_function */
 925          "R_SH_GLOB_DAT64",     /* name */
 926          FALSE,                 /* partial_inplace */
 927          0,                     /* src_mask */
 928          ((bfd_vma) 0) - 1,     /* dst_mask */
 929          FALSE),                /* pcrel_offset */
 930
 931   HOWTO (R_SH_JMP_SLOT64,       /* type */
 932          0,                     /* rightshift */
 933          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 934          64,                    /* bitsize */
 935          FALSE,                 /* pc_relative */
 936          0,                     /* bitpos */
 937          complain_overflow_dont, /* complain_on_overflow */
 938          bfd_elf_generic_reloc, /* special_function */
 939          "R_SH_JMP_SLOT64",     /* name */
 940          FALSE,                 /* partial_inplace */
 941          0,                     /* src_mask */
 942          ((bfd_vma) 0) - 1,     /* dst_mask */
 943          FALSE),                /* pcrel_offset */
 944
 945   HOWTO (R_SH_RELATIVE64,       /* type */
 946          0,                     /* rightshift */
 947          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 948          64,                    /* bitsize */
 949          FALSE,                 /* pc_relative */
 950          0,                     /* bitpos */
 951          complain_overflow_dont, /* complain_on_overflow */
 952          bfd_elf_generic_reloc, /* special_function */
 953          "R_SH_RELATIVE64",     /* name */
 954          FALSE,                 /* partial_inplace */
 955          0,                     /* src_mask */
 956          ((bfd_vma) 0) - 1,     /* dst_mask */
 957          FALSE),                /* pcrel_offset */
 958
 959   EMPTY_HOWTO (197),
 960   EMPTY_HOWTO (198),
 961   EMPTY_HOWTO (199),
 962   EMPTY_HOWTO (200),
 963   EMPTY_HOWTO (201),
 964   EMPTY_HOWTO (202),
 965   EMPTY_HOWTO (203),
 966   EMPTY_HOWTO (204),
 967   EMPTY_HOWTO (205),
 968   EMPTY_HOWTO (206),
 969   EMPTY_HOWTO (207),
 970   EMPTY_HOWTO (208),
 971   EMPTY_HOWTO (209),
 972   EMPTY_HOWTO (210),
 973   EMPTY_HOWTO (211),
 974   EMPTY_HOWTO (212),
 975   EMPTY_HOWTO (213),
 976   EMPTY_HOWTO (214),
 977   EMPTY_HOWTO (215),
 978   EMPTY_HOWTO (216),
 979   EMPTY_HOWTO (217),
 980   EMPTY_HOWTO (218),
 981   EMPTY_HOWTO (219),
 982   EMPTY_HOWTO (220),
 983   EMPTY_HOWTO (221),
 984   EMPTY_HOWTO (222),
 985   EMPTY_HOWTO (223),
 986   EMPTY_HOWTO (224),
 987   EMPTY_HOWTO (225),
 988   EMPTY_HOWTO (226),
 989   EMPTY_HOWTO (227),
 990   EMPTY_HOWTO (228),
 991   EMPTY_HOWTO (229),
 992   EMPTY_HOWTO (230),
 993   EMPTY_HOWTO (231),
 994   EMPTY_HOWTO (232),
 995   EMPTY_HOWTO (233),
 996   EMPTY_HOWTO (234),
 997   EMPTY_HOWTO (235),
 998   EMPTY_HOWTO (236),
 999   EMPTY_HOWTO (237),
1000   EMPTY_HOWTO (238),
1001   EMPTY_HOWTO (239),
1002   EMPTY_HOWTO (240),
1003   EMPTY_HOWTO (241),
1004
1005   /* Relocations for SHmedia code.  None of these are partial_inplace or
1006      use the field being relocated.  */
1007
1008   /* The assembler will generate this reloc before a block of SHmedia
1009      instructions.  A section should be processed as assuming it contains
1010      data, unless this reloc is seen.  Note that a block of SHcompact
1011      instructions are instead preceded by R_SH_CODE.
1012      This is currently not implemented, but should be used for SHmedia
1013      linker relaxation.  */
1014   HOWTO (R_SH_SHMEDIA_CODE,     /* type */
1015          0,                     /* rightshift */
1016          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1017          0,                     /* bitsize */
1018          FALSE,                 /* pc_relative */
1019          0,                     /* bitpos */
1020          complain_overflow_unsigned, /* complain_on_overflow */
1021          sh_elf64_ignore_reloc, /* special_function */
1022          "R_SH_SHMEDIA_CODE",   /* name */
1023          FALSE,                 /* partial_inplace */
1024          0,                     /* src_mask */
1025          0,                     /* dst_mask */
1026          FALSE),                /* pcrel_offset */
1027
1028   /* The assembler will generate this reloc at a PTA or PTB instruction,
1029      and the linker checks the right type of target, or changes a PTA to a
1030      PTB, if the original insn was PT.  */
1031   HOWTO (R_SH_PT_16,            /* type */
1032          2,                     /* rightshift */
1033          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1034          18,                    /* bitsize */
1035          TRUE,                  /* pc_relative */
1036          10,                    /* bitpos */
1037          complain_overflow_signed, /* complain_on_overflow */
1038          bfd_elf_generic_reloc, /* special_function */
1039          "R_SH_PT_16",          /* name */
1040          FALSE,                 /* partial_inplace */
1041          0,                     /* src_mask */
1042          0x3fffc00,             /* dst_mask */
1043          TRUE),                 /* pcrel_offset */
1044
1045   /* Used in unexpanded MOVI.  */
1046   HOWTO (R_SH_IMMS16,           /* type */
1047          0,                     /* rightshift */
1048          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1049          16,                    /* bitsize */
1050          FALSE,                 /* pc_relative */
1051          10,                    /* bitpos */
1052          complain_overflow_signed, /* complain_on_overflow */
1053          bfd_elf_generic_reloc, /* special_function */
1054          "R_SH_IMMS16",         /* name */
1055          FALSE,                 /* partial_inplace */
1056          0,                     /* src_mask */
1057          0x3fffc00,             /* dst_mask */
1058          FALSE),                /* pcrel_offset */
1059
1060   /* Used in SHORI.  */
1061   HOWTO (R_SH_IMMU16,           /* type */
1062          0,                     /* rightshift */
1063          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1064          16,                    /* bitsize */
1065          FALSE,                 /* pc_relative */
1066          10,                    /* bitpos */
1067          complain_overflow_unsigned, /* complain_on_overflow */
1068          bfd_elf_generic_reloc, /* special_function */
1069          "R_SH_IMMU16",         /* name */
1070          FALSE,                 /* partial_inplace */
1071          0,                     /* src_mask */
1072          0x3fffc00,             /* dst_mask */
1073          FALSE),                /* pcrel_offset */
1074
1075   /* Used in MOVI and SHORI (x & 65536).  */
1076   HOWTO (R_SH_IMM_LOW16,        /* type */
1077          0,                     /* rightshift */
1078          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1079          64,                    /* bitsize */
1080          FALSE,                 /* pc_relative */
1081          10,                    /* bitpos */
1082          complain_overflow_dont, /* complain_on_overflow */
1083          bfd_elf_generic_reloc, /* special_function */
1084          "R_SH_IMM_LOW16",      /* name */
1085          FALSE,                 /* partial_inplace */
1086          0,                     /* src_mask */
1087          0x3fffc00,             /* dst_mask */
1088          FALSE),                /* pcrel_offset */
1089
1090   /* Used in MOVI and SHORI ((x - $) & 65536).  */
1091   HOWTO (R_SH_IMM_LOW16_PCREL,  /* type */
1092          0,                     /* rightshift */
1093          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1094          64,                    /* bitsize */
1095          TRUE,                  /* pc_relative */
1096          10,                    /* bitpos */
1097          complain_overflow_dont, /* complain_on_overflow */
1098          bfd_elf_generic_reloc, /* special_function */
1099          "R_SH_IMM_LOW16_PCREL", /* name */
1100          FALSE,                 /* partial_inplace */
1101          0,                     /* src_mask */
1102          0x3fffc00,             /* dst_mask */
1103          TRUE),                 /* pcrel_offset */
1104
1105   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
1106   HOWTO (R_SH_IMM_MEDLOW16,     /* type */
1107          16,                    /* rightshift */
1108          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1109          64,                    /* bitsize */
1110          FALSE,                 /* pc_relative */
1111          10,                    /* bitpos */
1112          complain_overflow_dont, /* complain_on_overflow */
1113          bfd_elf_generic_reloc, /* special_function */
1114          "R_SH_IMM_MEDLOW16",   /* name */
1115          FALSE,                 /* partial_inplace */
1116          0,                     /* src_mask */
1117          0x3fffc00,             /* dst_mask */
1118          FALSE),                /* pcrel_offset */
1119
1120   /* Used in MOVI and SHORI (((x - $) >> 16) & 65536).  */
1121   HOWTO (R_SH_IMM_MEDLOW16_PCREL, /* type */
1122          16,                    /* rightshift */
1123          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1124          64,                    /* bitsize */
1125          TRUE,                  /* pc_relative */
1126          10,                    /* bitpos */
1127          complain_overflow_dont, /* complain_on_overflow */
1128          bfd_elf_generic_reloc, /* special_function */
1129          "R_SH_IMM_MEDLOW16_PCREL", /* name */
1130          FALSE,                 /* partial_inplace */
1131          0,                     /* src_mask */
1132          0x3fffc00,             /* dst_mask */
1133          TRUE),                 /* pcrel_offset */
1134
1135   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1136   HOWTO (R_SH_IMM_MEDHI16,      /* type */
1137          32,                    /* rightshift */
1138          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1139          64,                    /* bitsize */
1140          FALSE,                 /* pc_relative */
1141          10,                    /* bitpos */
1142          complain_overflow_dont, /* complain_on_overflow */
1143          bfd_elf_generic_reloc, /* special_function */
1144          "R_SH_IMM_MEDHI16",    /* name */
1145          FALSE,                 /* partial_inplace */
1146          0,                     /* src_mask */
1147          0x3fffc00,             /* dst_mask */
1148          FALSE),                /* pcrel_offset */
1149
1150   /* Used in MOVI and SHORI (((x - $) >> 32) & 65536).  */
1151   HOWTO (R_SH_IMM_MEDHI16_PCREL, /* type */
1152          32,                    /* rightshift */
1153          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1154          64,                    /* bitsize */
1155          TRUE,                  /* pc_relative */
1156          10,                    /* bitpos */
1157          complain_overflow_dont, /* complain_on_overflow */
1158          bfd_elf_generic_reloc, /* special_function */
1159          "R_SH_IMM_MEDHI16_PCREL", /* name */
1160          FALSE,                 /* partial_inplace */
1161          0,                     /* src_mask */
1162          0x3fffc00,             /* dst_mask */
1163          TRUE),                 /* pcrel_offset */
1164
1165   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1166   HOWTO (R_SH_IMM_HI16,         /* type */
1167          48,                    /* rightshift */
1168          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1169          64,                    /* bitsize */
1170          FALSE,                 /* pc_relative */
1171          10,                    /* bitpos */
1172          complain_overflow_dont, /* complain_on_overflow */
1173          bfd_elf_generic_reloc, /* special_function */
1174          "R_SH_IMM_HI16",       /* name */
1175          FALSE,                 /* partial_inplace */
1176          0,                     /* src_mask */
1177          0x3fffc00,             /* dst_mask */
1178          FALSE),                /* pcrel_offset */
1179
1180   /* Used in MOVI and SHORI (((x - $) >> 48) & 65536).  */
1181   HOWTO (R_SH_IMM_HI16_PCREL,   /* type */
1182          48,                    /* rightshift */
1183          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1184          64,                    /* bitsize */
1185          TRUE,                  /* pc_relative */
1186          10,                    /* bitpos */
1187          complain_overflow_dont, /* complain_on_overflow */
1188          bfd_elf_generic_reloc, /* special_function */
1189          "R_SH_IMM_HI16_PCREL", /* name */
1190          FALSE,                 /* partial_inplace */
1191          0,                     /* src_mask */
1192          0x3fffc00,             /* dst_mask */
1193          TRUE),                 /* pcrel_offset */
1194
1195   /* For the .uaquad pseudo.  */
1196   HOWTO (R_SH_64,               /* type */
1197          0,                     /* rightshift */
1198          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1199          64,                    /* bitsize */
1200          FALSE,                 /* pc_relative */
1201          0,                     /* bitpos */
1202          complain_overflow_dont, /* complain_on_overflow */
1203          bfd_elf_generic_reloc, /* special_function */
1204          "R_SH_64",             /* name */
1205          FALSE,                 /* partial_inplace */
1206          0,                     /* src_mask */
1207          ((bfd_vma) 0) - 1,     /* dst_mask */
1208          FALSE),                /* pcrel_offset */
1209
1210   /* For the .uaquad pseudo, (x - $).  */
1211   HOWTO (R_SH_64_PCREL,         /* type */
1212          48,                    /* rightshift */
1213          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1214          64,                    /* bitsize */
1215          TRUE,                  /* pc_relative */
1216          10,                    /* bitpos */
1217          complain_overflow_dont, /* complain_on_overflow */
1218          bfd_elf_generic_reloc, /* special_function */
1219          "R_SH_64_PCREL",       /* name */
1220          FALSE,                 /* partial_inplace */
1221          0,                     /* src_mask */
1222          ((bfd_vma) 0) - 1,     /* dst_mask */
1223          TRUE),                 /* pcrel_offset */
1224
1225 };
1226
1227 /* This function is used for relocs which are only used for relaxing,
1228    which the linker should otherwise ignore.  */
1229
1230 static bfd_reloc_status_type
1231 sh_elf64_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1232                        asymbol *symbol ATTRIBUTE_UNUSED,
1233                        void *data ATTRIBUTE_UNUSED, asection *input_section,
1234                        bfd *output_bfd,
1235                        char **error_message ATTRIBUTE_UNUSED)
1236 {
1237   if (output_bfd != NULL)
1238     reloc_entry->address += input_section->output_offset;
1239   return bfd_reloc_ok;
1240 }
1241
1242 /* This function is used for normal relocs.  This used to be like the COFF
1243    function, and is almost certainly incorrect for other ELF targets.
1244
1245    See sh_elf_reloc in elf32-sh.c for the original.  */
1246
1247 static bfd_reloc_status_type
1248 sh_elf64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol_in,
1249                 void *data, asection *input_section, bfd *output_bfd,
1250                 char **error_message ATTRIBUTE_UNUSED)
1251 {
1252   unsigned long insn;
1253   bfd_vma sym_value;
1254   enum elf_sh_reloc_type r_type;
1255   bfd_vma addr = reloc_entry->address;
1256   bfd_byte *hit_data = addr + (bfd_byte *) data;
1257
1258   r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
1259
1260   if (output_bfd != NULL)
1261     {
1262       /* Partial linking--do nothing.  */
1263       reloc_entry->address += input_section->output_offset;
1264       return bfd_reloc_ok;
1265     }
1266
1267   if (symbol_in != NULL
1268       && bfd_is_und_section (symbol_in->section))
1269     return bfd_reloc_undefined;
1270
1271   if (bfd_is_com_section (symbol_in->section))
1272     sym_value = 0;
1273   else
1274     sym_value = (symbol_in->value +
1275                  symbol_in->section->output_section->vma +
1276                  symbol_in->section->output_offset);
1277
1278   switch (r_type)
1279     {
1280     case R_SH_DIR32:
1281       insn = bfd_get_32 (abfd, hit_data);
1282       insn += sym_value + reloc_entry->addend;
1283       bfd_put_32 (abfd, insn, hit_data);
1284       break;
1285
1286     default:
1287       abort ();
1288       break;
1289     }
1290
1291   return bfd_reloc_ok;
1292 }
1293
1294 /* This structure is used to map BFD reloc codes to SH ELF relocs.  */
1295
1296 struct elf_reloc_map
1297 {
1298   bfd_reloc_code_real_type bfd_reloc_val;
1299   unsigned char elf_reloc_val;
1300 };
1301
1302 /* An array mapping BFD reloc codes to SH ELF relocs.  */
1303
1304 static const struct elf_reloc_map sh64_reloc_map[] =
1305 {
1306   { BFD_RELOC_NONE, R_SH_NONE },
1307   { BFD_RELOC_32, R_SH_DIR32 },
1308   { BFD_RELOC_CTOR, R_SH_DIR32 },
1309   { BFD_RELOC_32_PCREL, R_SH_REL32 },
1310   { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
1311   { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
1312   { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
1313   { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
1314   { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
1315   { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
1316   { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
1317   { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
1318   { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
1319   { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
1320   { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
1321   { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
1322   { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
1323   { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
1324   { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
1325   { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
1326   { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
1327   { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
1328   { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
1329   { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
1330   { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
1331   { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
1332   { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
1333   { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
1334   { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
1335   { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
1336   { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
1337   { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
1338   { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
1339   { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
1340   { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
1341   { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
1342   { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
1343   { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
1344   { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
1345   { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
1346   { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
1347   { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
1348   { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
1349   { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
1350   { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
1351   { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
1352   { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
1353   { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
1354   { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
1355   { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
1356   { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
1357   { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
1358   { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
1359   { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
1360   { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
1361   { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
1362   { BFD_RELOC_64, R_SH_64 },
1363   { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
1364 };
1365
1366 /* Given a BFD reloc code, return the howto structure for the
1367    corresponding SH ELf reloc.  */
1368
1369 static reloc_howto_type *
1370 sh_elf64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1371                             bfd_reloc_code_real_type code)
1372 {
1373   unsigned int i;
1374
1375   for (i = 0; i < sizeof (sh64_reloc_map) / sizeof (struct elf_reloc_map); i++)
1376     {
1377       if (sh64_reloc_map[i].bfd_reloc_val == code)
1378         return &sh_elf64_howto_table[(int) sh64_reloc_map[i].elf_reloc_val];
1379     }
1380
1381   return NULL;
1382 }
1383
1384 static reloc_howto_type *
1385 sh_elf64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1386                             const char *r_name)
1387 {
1388   unsigned int i;
1389
1390   for (i = 0;
1391        i < sizeof (sh_elf64_howto_table) / sizeof (sh_elf64_howto_table[0]);
1392        i++)
1393     if (sh_elf64_howto_table[i].name != NULL
1394         && strcasecmp (sh_elf64_howto_table[i].name, r_name) == 0)
1395       return &sh_elf64_howto_table[i];
1396
1397   return NULL;
1398 }
1399
1400 /* Given an ELF reloc, fill in the howto field of a relent.
1401
1402    See sh_elf_info_to_howto in elf32-sh.c for the original.  */
1403
1404 static void
1405 sh_elf64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
1406                         Elf_Internal_Rela *dst)
1407 {
1408   unsigned int r;
1409
1410   r = ELF64_R_TYPE (dst->r_info);
1411
1412   BFD_ASSERT (r <= (unsigned int) R_SH_64_PCREL);
1413   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
1414   BFD_ASSERT (r < R_SH_DIR8WPN || r > R_SH_LAST_INVALID_RELOC_2);
1415   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_GOTPLT32);
1416   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
1417
1418   cache_ptr->howto = &sh_elf64_howto_table[r];
1419 }
1420
1421 /* Relocate an SH ELF section.
1422
1423    See sh_elf_info_to_howto in elf32-sh.c for the original.  */
1424
1425 static bfd_boolean
1426 sh_elf64_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1427                            struct bfd_link_info *info, bfd *input_bfd,
1428                            asection *input_section, bfd_byte *contents,
1429                            Elf_Internal_Rela *relocs,
1430                            Elf_Internal_Sym *local_syms,
1431                            asection **local_sections)
1432 {
1433   Elf_Internal_Shdr *symtab_hdr;
1434   struct elf_link_hash_entry **sym_hashes;
1435   Elf_Internal_Rela *rel, *relend;
1436   bfd *dynobj;
1437   bfd_vma *local_got_offsets;
1438   asection *sgot;
1439   asection *sgotplt;
1440   asection *splt;
1441   asection *sreloc;
1442   bfd_vma disp, dropped;
1443
1444   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1445   sym_hashes = elf_sym_hashes (input_bfd);
1446   dynobj = elf_hash_table (info)->dynobj;
1447   local_got_offsets = elf_local_got_offsets (input_bfd);
1448
1449   sgot = NULL;
1450   sgotplt = NULL;
1451   splt = NULL;
1452   sreloc = NULL;
1453
1454   rel = relocs;
1455   relend = relocs + input_section->reloc_count;
1456   for (; rel < relend; rel++)
1457     {
1458       int r_type;
1459       reloc_howto_type *howto;
1460       unsigned long r_symndx;
1461       Elf_Internal_Sym *sym;
1462       asection *sec;
1463       struct elf_link_hash_entry *h;
1464       bfd_vma relocation;
1465       bfd_vma addend = (bfd_vma)0;
1466       bfd_reloc_status_type r;
1467       int seen_stt_datalabel = 0;
1468
1469       r_symndx = ELF64_R_SYM (rel->r_info);
1470
1471       r_type = ELF64_R_TYPE (rel->r_info);
1472
1473       if (r_type == (int) R_SH_NONE)
1474         continue;
1475
1476       if (r_type < 0
1477           || r_type > R_SH_64_PCREL
1478           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
1479               && r_type <= (int) R_SH_LAST_INVALID_RELOC)
1480           || (r_type >= (int) R_SH_DIR8WPN
1481               && r_type <= (int) R_SH_LAST_INVALID_RELOC)
1482           || (r_type >= (int) R_SH_GNU_VTINHERIT
1483               && r_type <= (int) R_SH_PSHL)
1484           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
1485               && r_type <= R_SH_GOTPLT32)
1486           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
1487               && r_type <= (int) R_SH_LAST_INVALID_RELOC_4))
1488         {
1489           bfd_set_error (bfd_error_bad_value);
1490           return FALSE;
1491         }
1492
1493       howto = sh_elf64_howto_table + r_type;
1494
1495       h = NULL;
1496       sym = NULL;
1497       sec = NULL;
1498       relocation = 0;
1499       if (r_symndx < symtab_hdr->sh_info)
1500         {
1501           sym = local_syms + r_symndx;
1502           sec = local_sections[r_symndx];
1503           relocation = ((sec->output_section->vma
1504                          + sec->output_offset
1505                          + sym->st_value)
1506                         | ((sym->st_other & STO_SH5_ISA32) != 0));
1507
1508           /* A local symbol never has STO_SH5_ISA32, so we don't need
1509              datalabel processing here.  Make sure this does not change
1510              without notice.  */
1511           if ((sym->st_other & STO_SH5_ISA32) != 0)
1512             ((*info->callbacks->reloc_dangerous)
1513              (info,
1514               _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
1515               input_bfd, input_section, rel->r_offset));
1516
1517           if (sec != NULL && elf_discarded_section (sec))
1518             /* Handled below.  */
1519             ;
1520           else if (info->relocatable)
1521             {
1522               /* This is a relocatable link.  We don't have to change
1523                  anything, unless the reloc is against a section symbol,
1524                  in which case we have to adjust according to where the
1525                  section symbol winds up in the output section.  */
1526               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1527                 goto final_link_relocate;
1528
1529               continue;
1530             }
1531           else if (! howto->partial_inplace)
1532             {
1533               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1534               relocation |= ((sym->st_other & STO_SH5_ISA32) != 0);
1535             }
1536           else if ((sec->flags & SEC_MERGE)
1537                    && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1538             {
1539               asection *msec;
1540
1541               if (howto->rightshift || howto->src_mask != 0xffffffff)
1542                 {
1543                   (*_bfd_error_handler)
1544                     (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
1545                      input_bfd, input_section,
1546                      (long) rel->r_offset, howto->name);
1547                   return FALSE;
1548                 }
1549
1550               addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
1551               msec = sec;
1552               addend =
1553                 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1554                 - relocation;
1555               addend += msec->output_section->vma + msec->output_offset;
1556               bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
1557               addend = 0;
1558             }
1559         }
1560       else
1561         {
1562           /* ??? Could we use the RELOC_FOR_GLOBAL_SYMBOL macro here ?  */
1563
1564           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1565           while (h->root.type == bfd_link_hash_indirect
1566                  || h->root.type == bfd_link_hash_warning)
1567             {
1568               /* If the reference passes a symbol marked with
1569                  STT_DATALABEL, then any STO_SH5_ISA32 on the final value
1570                  doesn't count.  */
1571               seen_stt_datalabel |= h->type == STT_DATALABEL;
1572               h = (struct elf_link_hash_entry *) h->root.u.i.link;
1573             }
1574
1575           if (h->root.type == bfd_link_hash_defined
1576               || h->root.type == bfd_link_hash_defweak)
1577             {
1578               sec = h->root.u.def.section;
1579               /* In these cases, we don't need the relocation value.
1580                  We check specially because in some obscure cases
1581                  sec->output_section will be NULL.  */
1582               if (r_type == R_SH_GOTPC_LOW16
1583                   || r_type == R_SH_GOTPC_MEDLOW16
1584                   || r_type == R_SH_GOTPC_MEDHI16
1585                   || r_type == R_SH_GOTPC_HI16
1586                   || ((r_type == R_SH_PLT_LOW16
1587                        || r_type == R_SH_PLT_MEDLOW16
1588                        || r_type == R_SH_PLT_MEDHI16
1589                        || r_type == R_SH_PLT_HI16)
1590                       && h->plt.offset != (bfd_vma) -1)
1591                   || ((r_type == R_SH_GOT_LOW16
1592                        || r_type == R_SH_GOT_MEDLOW16
1593                        || r_type == R_SH_GOT_MEDHI16
1594                        || r_type == R_SH_GOT_HI16)
1595                       && elf_hash_table (info)->dynamic_sections_created
1596                       && (! info->shared
1597                           || (! info->symbolic && h->dynindx != -1)
1598                           || !h->def_regular))
1599                   /* The cases above are those in which relocation is
1600                      overwritten in the switch block below.  The cases
1601                      below are those in which we must defer relocation
1602                      to run-time, because we can't resolve absolute
1603                      addresses when creating a shared library.  */
1604                   || (info->shared
1605                       && ((! info->symbolic && h->dynindx != -1)
1606                           || !h->def_regular)
1607                       && ((r_type == R_SH_64
1608                            && !(ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1609                                 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN))
1610                           || r_type == R_SH_64_PCREL)
1611                       && ((input_section->flags & SEC_ALLOC) != 0
1612                           /* DWARF will emit R_SH_DIR32 relocations in its
1613                              sections against symbols defined externally
1614                              in shared libraries.  We can't do anything
1615                              with them here.  */
1616                           || (input_section->flags & SEC_DEBUGGING) != 0))
1617                   /* Dynamic relocs are not propagated for SEC_DEBUGGING
1618                      sections because such sections are not SEC_ALLOC and
1619                      thus ld.so will not process them.  */
1620                   || (sec->output_section == NULL
1621                       && ((input_section->flags & SEC_DEBUGGING) != 0
1622                           && h->def_dynamic)))
1623                 ;
1624               else if (sec->output_section != NULL)
1625                 relocation = ((h->root.u.def.value
1626                                + sec->output_section->vma
1627                                + sec->output_offset)
1628                               /* A STO_SH5_ISA32 causes a "bitor 1" to the
1629                                  symbol value, unless we've seen
1630                                  STT_DATALABEL on the way to it.  */
1631                               | ((h->other & STO_SH5_ISA32) != 0
1632                                  && ! seen_stt_datalabel));
1633               else if (!info->relocatable)
1634                 {
1635                   (*_bfd_error_handler)
1636                     (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1637                      input_bfd,
1638                      input_section,
1639                      (long) rel->r_offset,
1640                      howto->name,
1641                      h->root.root.string);
1642                 }
1643             }
1644           else if (h->root.type == bfd_link_hash_undefweak)
1645             ;
1646           else if (info->unresolved_syms_in_objects == RM_IGNORE
1647                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1648             ;
1649           else if (!info->relocatable)
1650             {
1651               if (! ((*info->callbacks->undefined_symbol)
1652                      (info, h->root.root.string, input_bfd,
1653                       input_section, rel->r_offset,
1654                       (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1655                        || ELF_ST_VISIBILITY (h->other)))))
1656                 return FALSE;
1657             }
1658         }
1659
1660       if (sec != NULL && elf_discarded_section (sec))
1661         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1662                                          rel, relend, howto, contents);
1663
1664       if (info->relocatable)
1665         continue;
1666
1667       disp = (relocation
1668               - input_section->output_section->vma
1669               - input_section->output_offset
1670               - rel->r_offset);
1671       dropped = 0;
1672       switch ((int)r_type)
1673         {
1674         case R_SH_PT_16:     dropped = disp & 2; break;
1675         case R_SH_DIR10SW: dropped = disp & 1; break;
1676         case R_SH_DIR10SL: dropped = disp & 3; break;
1677         case R_SH_DIR10SQ: dropped = disp & 7; break;
1678         }
1679       if (dropped != 0)
1680         {
1681           (*_bfd_error_handler)
1682             (_("%s: error: unaligned relocation type %d at %08x reloc %08x\n"),
1683              bfd_get_filename (input_bfd), (int)r_type, (unsigned)rel->r_offset, (unsigned)relocation);
1684           bfd_set_error (bfd_error_bad_value);
1685           return FALSE;
1686         }
1687       switch ((int)r_type)
1688         {
1689         case R_SH_64:
1690         case R_SH_64_PCREL:
1691           if (info->shared
1692               && (input_section->flags & SEC_ALLOC) != 0
1693               && (r_type != R_SH_64_PCREL
1694                   || (h != NULL
1695                       && h->dynindx != -1
1696                       && (! info->symbolic
1697                           || !h->def_regular))))
1698             {
1699               Elf_Internal_Rela outrel;
1700               bfd_byte *loc;
1701               bfd_boolean skip, relocate;
1702
1703               /* When generating a shared object, these relocations
1704                  are copied into the output file to be resolved at run
1705                  time.  */
1706
1707               if (sreloc == NULL)
1708                 {
1709                   sreloc = _bfd_elf_get_dynamic_reloc_section
1710                     (input_bfd, input_section, /*rela?*/ TRUE);
1711                   if (sreloc == NULL)
1712                     return FALSE;
1713                 }
1714
1715               skip = FALSE;
1716               relocate = FALSE;
1717
1718               outrel.r_offset
1719                 = _bfd_elf_section_offset (output_bfd, info,
1720                                            input_section, rel->r_offset);
1721
1722               if (outrel.r_offset == (bfd_vma) -1)
1723                 skip = TRUE;
1724               else if (outrel.r_offset == (bfd_vma) -2)
1725                 skip = TRUE, relocate = TRUE;
1726
1727               outrel.r_offset += (input_section->output_section->vma
1728                                   + input_section->output_offset);
1729
1730               if (skip)
1731                 memset (&outrel, 0, sizeof outrel);
1732               else if (r_type == R_SH_64_PCREL)
1733                 {
1734                   BFD_ASSERT (h != NULL && h->dynindx != -1);
1735                   outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64_PCREL);
1736                   outrel.r_addend = rel->r_addend;
1737                 }
1738               else
1739                 {
1740                   /* h->dynindx may be -1 if this symbol was marked to
1741                      become local.  */
1742                   if (h == NULL
1743                       || ((info->symbolic || h->dynindx == -1)
1744                           && h->def_regular))
1745                     {
1746                       relocate = TRUE;
1747                       outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1748                       outrel.r_addend = relocation + rel->r_addend;
1749                     }
1750                   else
1751                     {
1752                       BFD_ASSERT (h->dynindx != -1);
1753                       outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64);
1754                       outrel.r_addend = relocation + rel->r_addend;
1755                     }
1756                 }
1757
1758               loc = sreloc->contents;
1759               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
1760               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1761
1762               /* If this reloc is against an external symbol, we do
1763                  not want to fiddle with the addend.  Otherwise, we
1764                  need to include the symbol value so that it becomes
1765                  an addend for the dynamic reloc.  */
1766               if (! relocate)
1767                 continue;
1768             }
1769           else if (r_type == R_SH_64)
1770             addend = rel->r_addend;
1771           goto final_link_relocate;
1772
1773         case R_SH_GOTPLT_LOW16:
1774         case R_SH_GOTPLT_MEDLOW16:
1775         case R_SH_GOTPLT_MEDHI16:
1776         case R_SH_GOTPLT_HI16:
1777         case R_SH_GOTPLT10BY4:
1778         case R_SH_GOTPLT10BY8:
1779           /* Relocation is to the entry for this symbol in the
1780              procedure linkage table.  */
1781
1782           if (h == NULL
1783               || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1784               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
1785               || ! info->shared
1786               || info->symbolic
1787               || h->dynindx == -1
1788               || h->plt.offset == (bfd_vma) -1
1789               || h->got.offset != (bfd_vma) -1)
1790             goto force_got;
1791
1792           /* Relocation is to the entry for this symbol in the global
1793              offset table extension for the procedure linkage table.  */
1794           if (sgotplt == NULL)
1795             {
1796               sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1797               BFD_ASSERT (sgotplt != NULL);
1798             }
1799
1800           relocation = (sgotplt->output_offset
1801                         + ((h->plt.offset / elf_sh64_sizeof_plt (info)
1802                             - 1 + 3) * 8));
1803
1804           relocation -= GOT_BIAS;
1805
1806           goto final_link_relocate;
1807
1808         force_got:
1809         case R_SH_GOT_LOW16:
1810         case R_SH_GOT_MEDLOW16:
1811         case R_SH_GOT_MEDHI16:
1812         case R_SH_GOT_HI16:
1813         case R_SH_GOT10BY4:
1814         case R_SH_GOT10BY8:
1815           /* Relocation is to the entry for this symbol in the global
1816              offset table.  */
1817           if (sgot == NULL)
1818             {
1819               sgot = bfd_get_section_by_name (dynobj, ".got");
1820               BFD_ASSERT (sgot != NULL);
1821             }
1822
1823           if (h != NULL)
1824             {
1825               bfd_vma off;
1826
1827               off = h->got.offset;
1828               if (seen_stt_datalabel)
1829                 {
1830                   struct elf_sh64_link_hash_entry *hsh;
1831
1832                   hsh = (struct elf_sh64_link_hash_entry *)h;
1833                   off = hsh->datalabel_got_offset;
1834                 }
1835               BFD_ASSERT (off != (bfd_vma) -1);
1836
1837               if (! elf_hash_table (info)->dynamic_sections_created
1838                   || (info->shared
1839                       && (info->symbolic || h->dynindx == -1
1840                           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1841                           || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1842                       && h->def_regular))
1843                 {
1844                   /* This is actually a static link, or it is a
1845                      -Bsymbolic link and the symbol is defined
1846                      locally, or the symbol was forced to be local
1847                      because of a version file.  We must initialize
1848                      this entry in the global offset table.  Since the
1849                      offset must always be a multiple of 4, we use the
1850                      least significant bit to record whether we have
1851                      initialized it already.
1852
1853                      When doing a dynamic link, we create a .rela.got
1854                      relocation entry to initialize the value.  This
1855                      is done in the finish_dynamic_symbol routine.  */
1856                   if ((off & 1) != 0)
1857                     off &= ~1;
1858                   else
1859                     {
1860                       bfd_put_64 (output_bfd, relocation,
1861                                   sgot->contents + off);
1862                       if (seen_stt_datalabel)
1863                         {
1864                           struct elf_sh64_link_hash_entry *hsh;
1865
1866                           hsh = (struct elf_sh64_link_hash_entry *)h;
1867                           hsh->datalabel_got_offset |= 1;
1868                         }
1869                       else
1870                         h->got.offset |= 1;
1871                     }
1872                 }
1873
1874               relocation = sgot->output_offset + off;
1875             }
1876           else
1877             {
1878               bfd_vma off;
1879
1880               if (rel->r_addend)
1881                 {
1882                   BFD_ASSERT (local_got_offsets != NULL
1883                               && (local_got_offsets[symtab_hdr->sh_info
1884                                                     + r_symndx]
1885                                   != (bfd_vma) -1));
1886
1887                   off = local_got_offsets[symtab_hdr->sh_info
1888                                           + r_symndx];
1889                 }
1890               else
1891                 {
1892                   BFD_ASSERT (local_got_offsets != NULL
1893                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
1894
1895                   off = local_got_offsets[r_symndx];
1896                 }
1897
1898               /* The offset must always be a multiple of 8.  We use
1899                  the least significant bit to record whether we have
1900                  already generated the necessary reloc.  */
1901               if ((off & 1) != 0)
1902                 off &= ~1;
1903               else
1904                 {
1905                   bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1906
1907                   if (info->shared)
1908                     {
1909                       asection *s;
1910                       Elf_Internal_Rela outrel;
1911                       bfd_byte *loc;
1912
1913                       s = bfd_get_section_by_name (dynobj, ".rela.got");
1914                       BFD_ASSERT (s != NULL);
1915
1916                       outrel.r_offset = (sgot->output_section->vma
1917                                          + sgot->output_offset
1918                                          + off);
1919                       outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1920                       outrel.r_addend = relocation;
1921                       loc = s->contents;
1922                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
1923                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1924                     }
1925
1926                   if (rel->r_addend)
1927                     local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
1928                   else
1929                     local_got_offsets[r_symndx] |= 1;
1930                 }
1931
1932               relocation = sgot->output_offset + off;
1933             }
1934
1935           relocation -= GOT_BIAS;
1936
1937           goto final_link_relocate;
1938
1939         case R_SH_GOTOFF_LOW16:
1940         case R_SH_GOTOFF_MEDLOW16:
1941         case R_SH_GOTOFF_MEDHI16:
1942         case R_SH_GOTOFF_HI16:
1943           /* Relocation is relative to the start of the global offset
1944              table.  */
1945
1946           if (sgot == NULL)
1947             {
1948               sgot = bfd_get_section_by_name (dynobj, ".got");
1949               BFD_ASSERT (sgot != NULL);
1950             }
1951
1952           /* Note that sgot->output_offset is not involved in this
1953              calculation.  We always want the start of .got.  If we
1954              defined _GLOBAL_OFFSET_TABLE in a different way, as is
1955              permitted by the ABI, we might have to change this
1956              calculation.  */
1957           relocation -= sgot->output_section->vma;
1958
1959           relocation -= GOT_BIAS;
1960
1961           addend = rel->r_addend;
1962
1963           goto final_link_relocate;
1964
1965         case R_SH_GOTPC_LOW16:
1966         case R_SH_GOTPC_MEDLOW16:
1967         case R_SH_GOTPC_MEDHI16:
1968         case R_SH_GOTPC_HI16:
1969           /* Use global offset table as symbol value.  */
1970
1971           if (sgot == NULL)
1972             {
1973               sgot = bfd_get_section_by_name (dynobj, ".got");
1974               BFD_ASSERT (sgot != NULL);
1975             }
1976
1977           relocation = sgot->output_section->vma;
1978
1979           relocation += GOT_BIAS;
1980
1981           addend = rel->r_addend;
1982
1983           goto final_link_relocate;
1984
1985         case R_SH_PLT_LOW16:
1986         case R_SH_PLT_MEDLOW16:
1987         case R_SH_PLT_MEDHI16:
1988         case R_SH_PLT_HI16:
1989           /* Relocation is to the entry for this symbol in the
1990              procedure linkage table.  */
1991
1992           /* Resolve a PLT reloc against a local symbol directly,
1993              without using the procedure linkage table.  */
1994           if (h == NULL)
1995             goto final_link_relocate;
1996
1997           if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1998               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1999             goto final_link_relocate;
2000
2001           if (h->plt.offset == (bfd_vma) -1)
2002             {
2003               /* We didn't make a PLT entry for this symbol.  This
2004                  happens when statically linking PIC code, or when
2005                  using -Bsymbolic.  */
2006               goto final_link_relocate;
2007             }
2008
2009           if (splt == NULL)
2010             {
2011               splt = bfd_get_section_by_name (dynobj, ".plt");
2012               BFD_ASSERT (splt != NULL);
2013             }
2014
2015           relocation = (splt->output_section->vma
2016                         + splt->output_offset
2017                         + h->plt.offset);
2018           relocation++;
2019
2020           addend = rel->r_addend;
2021
2022           goto final_link_relocate;
2023
2024         case R_SH_DIR32:
2025         case R_SH_SHMEDIA_CODE:
2026         case R_SH_PT_16:
2027         case R_SH_DIR5U:
2028         case R_SH_DIR6S:
2029         case R_SH_DIR6U:
2030         case R_SH_DIR10S:
2031         case R_SH_DIR10SW:
2032         case R_SH_DIR10SL:
2033         case R_SH_DIR10SQ:
2034         case R_SH_IMMS16:
2035         case R_SH_IMMU16:
2036         case R_SH_IMM_LOW16:
2037         case R_SH_IMM_LOW16_PCREL:
2038         case R_SH_IMM_MEDLOW16:
2039         case R_SH_IMM_MEDLOW16_PCREL:
2040         case R_SH_IMM_MEDHI16:
2041         case R_SH_IMM_MEDHI16_PCREL:
2042         case R_SH_IMM_HI16:
2043         case R_SH_IMM_HI16_PCREL:
2044           addend = rel->r_addend;
2045           /* Fall through.  */
2046         case R_SH_REL32:
2047         final_link_relocate:
2048           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2049                                         contents, rel->r_offset,
2050                                         relocation, addend);
2051           break;
2052
2053         default:
2054           bfd_set_error (bfd_error_bad_value);
2055           return FALSE;
2056
2057         }
2058
2059       if (r != bfd_reloc_ok)
2060         {
2061           switch (r)
2062             {
2063             default:
2064             case bfd_reloc_outofrange:
2065               abort ();
2066             case bfd_reloc_overflow:
2067               {
2068                 const char *name;
2069
2070                 if (h != NULL)
2071                   name = NULL;
2072                 else
2073                   {
2074                     name = (bfd_elf_string_from_elf_section
2075                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
2076                     if (name == NULL)
2077                       return FALSE;
2078                     if (*name == '\0')
2079                       name = bfd_section_name (input_bfd, sec);
2080                   }
2081                 if (! ((*info->callbacks->reloc_overflow)
2082                        (info, (h ? &h->root : NULL), name, howto->name,
2083                         (bfd_vma) 0, input_bfd, input_section,
2084                         rel->r_offset)))
2085                   return FALSE;
2086               }
2087               break;
2088             }
2089         }
2090     }
2091
2092   return TRUE;
2093 }
2094
2095 /* This is a version of bfd_generic_get_relocated_section_contents
2096    that uses sh_elf64_relocate_section.
2097
2098    See sh_elf_relocate_section in elf32-sh.c for the original.  */
2099
2100 static bfd_byte *
2101 sh_elf64_get_relocated_section_contents (bfd *output_bfd,
2102                                          struct bfd_link_info *link_info,
2103                                          struct bfd_link_order *link_order,
2104                                          bfd_byte *data,
2105                                          bfd_boolean relocatable,
2106                                          asymbol **symbols)
2107 {
2108   Elf_Internal_Shdr *symtab_hdr;
2109   asection *input_section = link_order->u.indirect.section;
2110   bfd *input_bfd = input_section->owner;
2111   asection **sections = NULL;
2112   Elf_Internal_Rela *internal_relocs = NULL;
2113   Elf_Internal_Sym *isymbuf = NULL;
2114
2115   /* We only need to handle the case of relaxing, or of having a
2116      particular set of section contents, specially.  */
2117   if (relocatable
2118       || elf_section_data (input_section)->this_hdr.contents == NULL)
2119     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2120                                                        link_order, data,
2121                                                        relocatable,
2122                                                        symbols);
2123
2124   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2125
2126   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2127           input_section->size);
2128
2129   if ((input_section->flags & SEC_RELOC) != 0
2130       && input_section->reloc_count > 0)
2131     {
2132       Elf_Internal_Sym *isymp;
2133       Elf_Internal_Sym *isymend;
2134       asection **secpp;
2135
2136       /* Read this BFD's local symbols.  */
2137       if (symtab_hdr->sh_info != 0)
2138         {
2139           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2140           if (isymbuf == NULL)
2141             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2142                                             symtab_hdr->sh_info, 0,
2143                                             NULL, NULL, NULL);
2144           if (isymbuf == NULL)
2145             goto error_return;
2146         }
2147
2148       internal_relocs = (_bfd_elf_link_read_relocs
2149                          (input_bfd, input_section, NULL,
2150                           (Elf_Internal_Rela *) NULL, FALSE));
2151       if (internal_relocs == NULL)
2152         goto error_return;
2153
2154       sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2155                                            * sizeof (asection *));
2156       if (sections == NULL && symtab_hdr->sh_info > 0)
2157         goto error_return;
2158
2159       secpp = sections;
2160       isymend = isymbuf + symtab_hdr->sh_info;
2161       for (isymp = isymbuf; isymp < isymend; ++isymp, ++secpp)
2162         {
2163           asection *isec;
2164
2165           if (isymp->st_shndx == SHN_UNDEF)
2166             isec = bfd_und_section_ptr;
2167           else if (isymp->st_shndx == SHN_ABS)
2168             isec = bfd_abs_section_ptr;
2169           else if (isymp->st_shndx == SHN_COMMON)
2170             isec = bfd_com_section_ptr;
2171           else
2172             isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2173
2174           *secpp = isec;
2175         }
2176
2177       if (! sh_elf64_relocate_section (output_bfd, link_info, input_bfd,
2178                                        input_section, data, internal_relocs,
2179                                        isymbuf, sections))
2180         goto error_return;
2181
2182       if (sections != NULL)
2183         free (sections);
2184       if (internal_relocs != elf_section_data (input_section)->relocs)
2185         free (internal_relocs);
2186       if (isymbuf != NULL
2187           && (unsigned char *) isymbuf != symtab_hdr->contents)
2188         free (isymbuf);
2189     }
2190
2191   return data;
2192
2193  error_return:
2194   if (sections != NULL)
2195     free (sections);
2196   if (internal_relocs != NULL
2197       && internal_relocs != elf_section_data (input_section)->relocs)
2198     free (internal_relocs);
2199   if (isymbuf != NULL
2200       && (unsigned char *) isymbuf != symtab_hdr->contents)
2201     free (isymbuf);
2202   return NULL;
2203 }
2204
2205 /* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections.  */
2206
2207 static bfd_boolean
2208 sh64_elf64_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2209                           Elf_Internal_Shdr *elf_section_hdr,
2210                           asection *asect)
2211 {
2212   /* Code sections can only contain SH64 code, so mark them as such.  */
2213   if (bfd_get_section_flags (output_bfd, asect) & SEC_CODE)
2214     elf_section_hdr->sh_flags |= SHF_SH5_ISA32;
2215
2216   return TRUE;
2217 }
2218
2219 static bfd_boolean
2220 sh_elf64_set_mach_from_flags (bfd *abfd)
2221 {
2222   flagword flags = elf_elfheader (abfd)->e_flags;
2223
2224   switch (flags & EF_SH_MACH_MASK)
2225     {
2226     case EF_SH5:
2227       /* Just one, but keep the switch construct to make additions easy.  */
2228       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
2229       break;
2230
2231     default:
2232       bfd_set_error (bfd_error_wrong_format);
2233       return FALSE;
2234     }
2235   return TRUE;
2236 }
2237
2238 /* Function to keep SH64 specific file flags.
2239
2240    See sh64_elf_set_private_flags in elf32-sh64.c for the original.  */
2241
2242 static bfd_boolean
2243 sh_elf64_set_private_flags (bfd *abfd, flagword flags)
2244 {
2245   BFD_ASSERT (! elf_flags_init (abfd)
2246               || elf_elfheader (abfd)->e_flags == flags);
2247
2248   elf_elfheader (abfd)->e_flags = flags;
2249   elf_flags_init (abfd) = TRUE;
2250   return sh_elf64_set_mach_from_flags (abfd);
2251 }
2252
2253 /* Copy the SHF_SH5_ISA32 attribute that we keep on all sections with
2254    code, to keep attributes the same as for SHmedia in 32-bit ELF.  */
2255
2256 static bfd_boolean
2257 sh_elf64_copy_private_data_internal (bfd *ibfd, bfd *obfd)
2258 {
2259   Elf_Internal_Shdr **o_shdrp;
2260   asection *isec;
2261   asection *osec;
2262
2263   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2264       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2265     return TRUE;
2266
2267   o_shdrp = elf_elfsections (obfd);
2268   for (osec = obfd->sections; osec; osec = osec->next)
2269     {
2270       int oIndex = ((struct bfd_elf_section_data *) elf_section_data (osec))->this_idx;
2271       for (isec = ibfd->sections; isec; isec = isec->next)
2272         {
2273           if (strcmp (osec->name, isec->name) == 0)
2274             {
2275               /* Note that we're not disallowing mixing data and code.  */
2276               if ((elf_section_data (isec)->this_hdr.sh_flags
2277                    & SHF_SH5_ISA32) != 0)
2278                 o_shdrp[oIndex]->sh_flags |= SHF_SH5_ISA32;
2279               break;
2280             }
2281         }
2282     }
2283
2284   /* Copy object attributes.  */
2285   _bfd_elf_copy_obj_attributes (ibfd, obfd);
2286
2287   return sh_elf64_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
2288 }
2289
2290 static bfd_boolean
2291 sh_elf64_copy_private_data (bfd *ibfd, bfd *obfd)
2292 {
2293   return sh_elf64_copy_private_data_internal (ibfd, obfd);
2294 }
2295
2296 static bfd_boolean
2297 sh_elf64_merge_private_data (bfd *ibfd, bfd *obfd)
2298 {
2299   flagword old_flags, new_flags;
2300
2301   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2302     return FALSE;
2303
2304   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2305       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2306     return TRUE;
2307
2308   if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
2309     {
2310       const char *msg;
2311
2312       if (bfd_get_arch_size (ibfd) == 32
2313           && bfd_get_arch_size (obfd) == 64)
2314         msg = _("%s: compiled as 32-bit object and %s is 64-bit");
2315       else if (bfd_get_arch_size (ibfd) == 64
2316                && bfd_get_arch_size (obfd) == 32)
2317         msg = _("%s: compiled as 64-bit object and %s is 32-bit");
2318       else
2319         msg = _("%s: object size does not match that of target %s");
2320
2321       (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
2322                              bfd_get_filename (obfd));
2323       bfd_set_error (bfd_error_wrong_format);
2324       return FALSE;
2325     }
2326
2327   old_flags = elf_elfheader (obfd)->e_flags;
2328   new_flags = elf_elfheader (ibfd)->e_flags;
2329   if (! elf_flags_init (obfd))
2330     {
2331       /* This happens when ld starts out with a 'blank' output file.  */
2332       elf_flags_init (obfd) = TRUE;
2333       elf_elfheader (obfd)->e_flags = old_flags = new_flags;
2334     }
2335   /* We don't allow linking in anything else than SH64 code, and since
2336      this is a 64-bit ELF, we assume the 64-bit ABI is used.  Add code
2337      here as things change.  */
2338   else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
2339     {
2340       (*_bfd_error_handler)
2341         ("%s: does not use the SH64 64-bit ABI as previous modules do",
2342          bfd_get_filename (ibfd));
2343       bfd_set_error (bfd_error_bad_value);
2344       return FALSE;
2345     }
2346
2347   sh_elf64_copy_private_data_internal (ibfd, obfd);
2348
2349   /* I can't think of anything sane other than old_flags being EF_SH5 and
2350      that we need to preserve that.  */
2351   elf_elfheader (obfd)->e_flags = old_flags;
2352
2353   return sh_elf64_set_mach_from_flags (obfd);
2354 }
2355
2356 /* Return the section that should be marked against GC for a given
2357    relocation.  */
2358
2359 static asection *
2360 sh_elf64_gc_mark_hook (asection *sec,
2361                        struct bfd_link_info *info,
2362                        Elf_Internal_Rela *rel,
2363                        struct elf_link_hash_entry *h,
2364                        Elf_Internal_Sym *sym)
2365 {
2366   if (h != NULL)
2367     switch (ELF64_R_TYPE (rel->r_info))
2368       {
2369       case R_SH_GNU_VTINHERIT:
2370       case R_SH_GNU_VTENTRY:
2371         return NULL;
2372       }
2373
2374   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2375 }
2376
2377 /* Look through the relocs for a section during the first phase.
2378    Since we don't do .gots or .plts, we just need to consider the
2379    virtual table relocs for gc.  */
2380
2381 static bfd_boolean
2382 sh_elf64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2383                        asection *sec, const Elf_Internal_Rela *relocs)
2384 {
2385   Elf_Internal_Shdr *symtab_hdr;
2386   struct elf_link_hash_entry **sym_hashes;
2387   const Elf_Internal_Rela *rel;
2388   const Elf_Internal_Rela *rel_end;
2389   bfd *dynobj;
2390   bfd_vma *local_got_offsets;
2391   asection *sgot;
2392   asection *srelgot;
2393   asection *sreloc;
2394
2395   sgot = NULL;
2396   srelgot = NULL;
2397   sreloc = NULL;
2398
2399   if (info->relocatable)
2400     return TRUE;
2401
2402   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2403   sym_hashes = elf_sym_hashes (abfd);
2404
2405   dynobj = elf_hash_table (info)->dynobj;
2406   local_got_offsets = elf_local_got_offsets (abfd);
2407
2408   rel_end = relocs + sec->reloc_count;
2409   for (rel = relocs; rel < rel_end; rel++)
2410     {
2411       struct elf_link_hash_entry *h;
2412       unsigned long r_symndx;
2413
2414       r_symndx = ELF64_R_SYM (rel->r_info);
2415       if (r_symndx < symtab_hdr->sh_info)
2416         h = NULL;
2417       else
2418         {
2419           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2420           while (h->root.type == bfd_link_hash_indirect
2421                  || h->root.type == bfd_link_hash_warning)
2422             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2423         }
2424
2425       /* Some relocs require a global offset table.  */
2426       if (dynobj == NULL)
2427         {
2428           switch (ELF64_R_TYPE (rel->r_info))
2429             {
2430             case R_SH_GOTPLT_LOW16:
2431             case R_SH_GOTPLT_MEDLOW16:
2432             case R_SH_GOTPLT_MEDHI16:
2433             case R_SH_GOTPLT_HI16:
2434             case R_SH_GOTPLT10BY4:
2435             case R_SH_GOTPLT10BY8:
2436             case R_SH_GOT_LOW16:
2437             case R_SH_GOT_MEDLOW16:
2438             case R_SH_GOT_MEDHI16:
2439             case R_SH_GOT_HI16:
2440             case R_SH_GOT10BY4:
2441             case R_SH_GOT10BY8:
2442             case R_SH_GOTOFF_LOW16:
2443             case R_SH_GOTOFF_MEDLOW16:
2444             case R_SH_GOTOFF_MEDHI16:
2445             case R_SH_GOTOFF_HI16:
2446             case R_SH_GOTPC_LOW16:
2447             case R_SH_GOTPC_MEDLOW16:
2448             case R_SH_GOTPC_MEDHI16:
2449             case R_SH_GOTPC_HI16:
2450               elf_hash_table (info)->dynobj = dynobj = abfd;
2451               if (! _bfd_elf_create_got_section (dynobj, info))
2452                 return FALSE;
2453               break;
2454
2455             default:
2456               break;
2457             }
2458         }
2459
2460       switch (ELF64_R_TYPE (rel->r_info))
2461         {
2462           /* This relocation describes the C++ object vtable hierarchy.
2463              Reconstruct it for later use during GC.  */
2464         case R_SH_GNU_VTINHERIT:
2465           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2466             return FALSE;
2467           break;
2468
2469           /* This relocation describes which C++ vtable entries are actually
2470              used.  Record for later use during GC.  */
2471         case R_SH_GNU_VTENTRY:
2472           BFD_ASSERT (h != NULL);
2473           if (h != NULL
2474               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2475             return FALSE;
2476           break;
2477
2478         force_got:
2479         case R_SH_GOT_LOW16:
2480         case R_SH_GOT_MEDLOW16:
2481         case R_SH_GOT_MEDHI16:
2482         case R_SH_GOT_HI16:
2483         case R_SH_GOT10BY4:
2484         case R_SH_GOT10BY8:
2485           /* This symbol requires a global offset table entry.  */
2486
2487           if (sgot == NULL)
2488             {
2489               sgot = bfd_get_section_by_name (dynobj, ".got");
2490               BFD_ASSERT (sgot != NULL);
2491             }
2492
2493           if (srelgot == NULL
2494               && (h != NULL || info->shared))
2495             {
2496               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2497               if (srelgot == NULL)
2498                 {
2499                   srelgot = bfd_make_section_with_flags (dynobj,
2500                                                          ".rela.got",
2501                                                          (SEC_ALLOC
2502                                                           | SEC_LOAD
2503                                                           | SEC_HAS_CONTENTS
2504                                                           | SEC_IN_MEMORY
2505                                                           | SEC_LINKER_CREATED
2506                                                           | SEC_READONLY));
2507                   if (srelgot == NULL
2508                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2509                     return FALSE;
2510                 }
2511             }
2512
2513           if (h != NULL)
2514             {
2515               if (h->type == STT_DATALABEL)
2516                 {
2517                   struct elf_sh64_link_hash_entry *hsh;
2518
2519                   h = (struct elf_link_hash_entry *) h->root.u.i.link;
2520                   hsh = (struct elf_sh64_link_hash_entry *)h;
2521                   if (hsh->datalabel_got_offset != (bfd_vma) -1)
2522                     break;
2523
2524                   hsh->datalabel_got_offset = sgot->size;
2525                 }
2526               else
2527                 {
2528                   if (h->got.offset != (bfd_vma) -1)
2529                     {
2530                       /* We have already allocated space in the .got.  */
2531                       break;
2532                     }
2533                   h->got.offset = sgot->size;
2534                 }
2535
2536               /* Make sure this symbol is output as a dynamic symbol.  */
2537               if (h->dynindx == -1)
2538                 {
2539                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
2540                     return FALSE;
2541                 }
2542
2543               srelgot->size += sizeof (Elf64_External_Rela);
2544             }
2545           else
2546             {
2547               /* This is a global offset table entry for a local
2548                  symbol.  */
2549               if (local_got_offsets == NULL)
2550                 {
2551                   size_t size;
2552                   register unsigned int i;
2553
2554                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
2555                   /* Reserve space for both the datalabel and
2556                      codelabel local GOT offsets.  */
2557                   size *= 2;
2558                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2559                   if (local_got_offsets == NULL)
2560                     return FALSE;
2561                   elf_local_got_offsets (abfd) = local_got_offsets;
2562                   for (i = 0; i < symtab_hdr->sh_info; i++)
2563                     local_got_offsets[i] = (bfd_vma) -1;
2564                   for (; i < 2 * symtab_hdr->sh_info; i++)
2565                     local_got_offsets[i] = (bfd_vma) -1;
2566                 }
2567               if ((rel->r_addend & 1) != 0)
2568                 {
2569                   if (local_got_offsets[symtab_hdr->sh_info
2570                                         + r_symndx] != (bfd_vma) -1)
2571                     {
2572                       /* We have already allocated space in the .got.  */
2573                       break;
2574                     }
2575                   local_got_offsets[symtab_hdr->sh_info
2576                                     + r_symndx] = sgot->size;
2577                 }
2578               else
2579                 {
2580                   if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2581                     {
2582                       /* We have already allocated space in the .got.  */
2583                       break;
2584                     }
2585                   local_got_offsets[r_symndx] = sgot->size;
2586                 }
2587
2588               if (info->shared)
2589                 {
2590                   /* If we are generating a shared object, we need to
2591                      output a R_SH_RELATIVE reloc so that the dynamic
2592                      linker can adjust this GOT entry.  */
2593                   srelgot->size += sizeof (Elf64_External_Rela);
2594                 }
2595             }
2596
2597           sgot->size += 8;
2598
2599           break;
2600
2601         case R_SH_GOTPLT_LOW16:
2602         case R_SH_GOTPLT_MEDLOW16:
2603         case R_SH_GOTPLT_MEDHI16:
2604         case R_SH_GOTPLT_HI16:
2605         case R_SH_GOTPLT10BY4:
2606         case R_SH_GOTPLT10BY8:
2607           /* If this is a local symbol, we resolve it directly without
2608              creating a procedure linkage table entry.  */
2609
2610           if (h == NULL
2611               || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2612               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2613               || ! info->shared
2614               || info->symbolic
2615               || h->dynindx == -1
2616               || h->got.offset != (bfd_vma) -1)
2617             goto force_got;
2618
2619           /* Make sure this symbol is output as a dynamic symbol.  */
2620           if (h->dynindx == -1)
2621             {
2622               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2623                 return FALSE;
2624             }
2625
2626           h->needs_plt = 1;
2627
2628           break;
2629
2630         case R_SH_PLT_LOW16:
2631         case R_SH_PLT_MEDLOW16:
2632         case R_SH_PLT_MEDHI16:
2633         case R_SH_PLT_HI16:
2634           /* This symbol requires a procedure linkage table entry.  We
2635              actually build the entry in adjust_dynamic_symbol,
2636              because this might be a case of linking PIC code which is
2637              never referenced by a dynamic object, in which case we
2638              don't need to generate a procedure linkage table entry
2639              after all.  */
2640
2641           /* If this is a local symbol, we resolve it directly without
2642              creating a procedure linkage table entry.  */
2643           if (h == NULL)
2644             continue;
2645
2646           if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2647               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
2648             break;
2649
2650           h->needs_plt = 1;
2651
2652           break;
2653
2654         case R_SH_64:
2655         case R_SH_64_PCREL:
2656           if (h != NULL)
2657             h->non_got_ref = 1;
2658
2659           /* If we are creating a shared library, and this is a reloc
2660              against a global symbol, or a non PC relative reloc
2661              against a local symbol, then we need to copy the reloc
2662              into the shared library.  However, if we are linking with
2663              -Bsymbolic, we do not need to copy a reloc against a
2664              global symbol which is defined in an object we are
2665              including in the link (i.e., DEF_REGULAR is set).  At
2666              this point we have not seen all the input files, so it is
2667              possible that DEF_REGULAR is not set now but will be set
2668              later (it is never cleared).  We account for that
2669              possibility below by storing information in the
2670              pcrel_relocs_copied field of the hash table entry.  */
2671           if (info->shared
2672               && (sec->flags & SEC_ALLOC) != 0
2673               && (ELF32_R_TYPE (rel->r_info) != R_SH_64_PCREL
2674                   || (h != NULL
2675                       && (! info->symbolic
2676                           || !h->def_regular))))
2677             {
2678               /* When creating a shared object, we must copy these
2679                  reloc types into the output file.  We create a reloc
2680                  section in dynobj and make room for this reloc.  */
2681               if (sreloc == NULL)
2682                 {
2683                   sreloc = _bfd_elf_make_dynamic_reloc_section
2684                     (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2685
2686                   if (sreloc == NULL)
2687                     return FALSE;
2688                 }
2689
2690               sreloc->size += sizeof (Elf64_External_Rela);
2691
2692               /* If we are linking with -Bsymbolic, and this is a
2693                  global symbol, we count the number of PC relative
2694                  relocations we have entered for this symbol, so that
2695                  we can discard them again if the symbol is later
2696                  defined by a regular object.  Note that this function
2697                  is only called if we are using an elf_sh linker
2698                  hash table, which means that h is really a pointer to
2699                  an elf_sh_link_hash_entry.  */
2700               if (h != NULL && info->symbolic
2701                   && ELF64_R_TYPE (rel->r_info) == R_SH_64_PCREL)
2702                 {
2703                   struct elf_sh64_link_hash_entry *eh;
2704                   struct elf_sh64_pcrel_relocs_copied *p;
2705
2706                   eh = (struct elf_sh64_link_hash_entry *) h;
2707
2708                   for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2709                     if (p->section == sreloc)
2710                       break;
2711
2712                   if (p == NULL)
2713                     {
2714                       p = ((struct elf_sh64_pcrel_relocs_copied *)
2715                            bfd_alloc (dynobj, sizeof *p));
2716                       if (p == NULL)
2717                         return FALSE;
2718                       p->next = eh->pcrel_relocs_copied;
2719                       eh->pcrel_relocs_copied = p;
2720                       p->section = sreloc;
2721                       p->count = 0;
2722                     }
2723
2724                   ++p->count;
2725                 }
2726             }
2727
2728           break;
2729         }
2730     }
2731
2732   return TRUE;
2733 }
2734
2735 static int
2736 sh64_elf64_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
2737 {
2738   if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
2739     return STT_DATALABEL;
2740
2741   return type;
2742 }
2743
2744 /* FIXME: This is a copy of sh64_elf_add_symbol_hook in elf32-sh64.c.
2745    Either file can presumably exist without the other, but do not differ
2746    in elf-size-ness.  How to share?
2747
2748    Hook called by the linker routine which adds symbols from an object
2749    file.  We must make indirect symbols for undefined symbols marked with
2750    STT_DATALABEL, so relocations passing them will pick up that attribute
2751    and neutralize STO_SH5_ISA32 found on the symbol definition.
2752
2753    There is a problem, though: We want to fill in the hash-table entry for
2754    this symbol and signal to the caller that no further processing is
2755    needed.  But we don't have the index for this hash-table entry.  We
2756    rely here on that the current entry is the first hash-entry with NULL,
2757    which seems brittle.  Also, iterating over the hash-table to find that
2758    entry is a linear operation on the number of symbols in this input
2759    file, and this function should take constant time, so that's not good
2760    too.  Only comfort is that DataLabel references should only be found in
2761    hand-written assembly code and thus be rare.  FIXME: Talk maintainers
2762    into adding an option to elf_add_symbol_hook (preferably) for the index
2763    or the hash entry, alternatively adding the index to Elf_Internal_Sym
2764    (not so good).  */
2765
2766 static bfd_boolean
2767 sh64_elf64_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
2768                             Elf_Internal_Sym *sym, const char **namep,
2769                             flagword *flagsp ATTRIBUTE_UNUSED,
2770                             asection **secp, bfd_vma *valp)
2771 {
2772   /* We want to do this for relocatable as well as final linking.  */
2773   if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
2774       && is_elf_hash_table (info->hash))
2775     {
2776       struct elf_link_hash_entry *h;
2777
2778       /* For relocatable links, we register the DataLabel sym in its own
2779          right, and tweak the name when it's output.  Otherwise, we make
2780          an indirect symbol of it.  */
2781       flagword flags
2782         = info->relocatable || info->emitrelocations
2783         ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
2784
2785       char *dl_name
2786         = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
2787       struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
2788
2789       BFD_ASSERT (sym_hash != NULL);
2790
2791       /* Allocation may fail.  */
2792       if (dl_name == NULL)
2793         return FALSE;
2794
2795       strcpy (dl_name, *namep);
2796       strcat (dl_name, DATALABEL_SUFFIX);
2797
2798       h = (struct elf_link_hash_entry *)
2799         bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
2800
2801       if (h == NULL)
2802         {
2803           /* No previous datalabel symbol.  Make one.  */
2804           struct bfd_link_hash_entry *bh = NULL;
2805           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2806
2807           if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
2808                                                   flags, *secp, *valp,
2809                                                   *namep, FALSE,
2810                                                   bed->collect, &bh))
2811             {
2812               free (dl_name);
2813               return FALSE;
2814             }
2815
2816           h = (struct elf_link_hash_entry *) bh;
2817           h->non_elf = 0;
2818           h->type = STT_DATALABEL;
2819         }
2820       else
2821         /* If a new symbol was created, it holds the allocated name.
2822            Otherwise, we don't need it anymore and should deallocate it.  */
2823         free (dl_name);
2824
2825       if (h->type != STT_DATALABEL
2826           || ((info->relocatable || info->emitrelocations)
2827               && h->root.type != bfd_link_hash_undefined)
2828           || (! info->relocatable && !info->emitrelocations
2829               && h->root.type != bfd_link_hash_indirect))
2830         {
2831           /* Make sure we don't get confused on invalid input.  */
2832           (*_bfd_error_handler)
2833             (_("%s: encountered datalabel symbol in input"),
2834              bfd_get_filename (abfd));
2835           bfd_set_error (bfd_error_bad_value);
2836           return FALSE;
2837         }
2838
2839       /* Now find the hash-table slot for this entry and fill it in.  */
2840       while (*sym_hash != NULL)
2841         sym_hash++;
2842       *sym_hash = h;
2843
2844       /* Signal to caller to skip this symbol - we've handled it.  */
2845       *namep = NULL;
2846     }
2847
2848   return TRUE;
2849 }
2850
2851 /* This hook function is called before the linker writes out a global
2852    symbol.  For relocatable links, DataLabel symbols will be present in
2853    linker output.  We cut off the special suffix on those symbols, so the
2854    right name appears in the output.
2855
2856    When linking and emitting relocations, there can appear global symbols
2857    that are not referenced by relocs, but rather only implicitly through
2858    DataLabel references, a relation that is not visible to the linker.
2859    Since no stripping of global symbols in done when doing such linking,
2860    we don't need to look up and make sure to emit the main symbol for each
2861    DataLabel symbol.  */
2862
2863 static int
2864 sh64_elf64_link_output_symbol_hook (struct bfd_link_info *info,
2865                                     const char *cname,
2866                                     Elf_Internal_Sym *sym,
2867                                     asection *input_sec ATTRIBUTE_UNUSED,
2868                                     struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
2869 {
2870   char *name = (char *) cname;
2871
2872   if (info->relocatable || info->emitrelocations)
2873     {
2874       if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
2875         name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
2876     }
2877
2878   return 1;
2879 }
2880
2881 /* Set bit 0 on the entry address; it always points to SHmedia code.  This
2882    is mostly for symmetry with the 32-bit format, where code can be
2883    SHcompact and we need to make a distinction to make sure execution
2884    starts in the right ISA mode.  It is also convenient for a loader,
2885    which would otherwise have to set this bit when loading a TR register
2886    before jumping to the program entry.  */
2887
2888 static void
2889 sh64_elf64_final_write_processing (bfd *abfd,
2890                                    bfd_boolean linker ATTRIBUTE_UNUSED)
2891 {
2892   /* FIXME: Perhaps we shouldn't do this if the entry address was supplied
2893      numerically, but we currently lack the infrastructure to recognize
2894      that: The entry symbol, and info whether it is numeric or a symbol
2895      name is kept private in the linker.  */
2896   if (elf_elfheader (abfd)->e_type == ET_EXEC)
2897     elf_elfheader (abfd)->e_entry |= 1;
2898 }
2899
2900 /* First entry in an absolute procedure linkage table look like this.  */
2901
2902 static const bfd_byte elf_sh64_plt0_entry_be[PLT_ENTRY_SIZE] =
2903 {
2904   0xcc, 0x00, 0x01, 0x10, /* movi  .got.plt >> 48, r17 */
2905   0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 32) & 65535, r17 */
2906   0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 16) & 65535, r17 */
2907   0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
2908   0x8d, 0x10, 0x09, 0x90, /* ld.q  r17, 16, r25 */
2909   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2910   0x8d, 0x10, 0x05, 0x10, /* ld.q  r17, 8, r17 */
2911   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2912   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2913   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2914   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2915   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2916   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2917   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2918   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2919   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2920 };
2921
2922 static const bfd_byte elf_sh64_plt0_entry_le[PLT_ENTRY_SIZE] =
2923 {
2924   0x10, 0x01, 0x00, 0xcc, /* movi  .got.plt >> 16, r17 */
2925   0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 32) & 65535, r17 */
2926   0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 16) & 65535, r17 */
2927   0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
2928   0x90, 0x09, 0x10, 0x8d, /* ld.q  r17, 16, r25 */
2929   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2930   0x10, 0x05, 0x10, 0x8d, /* ld.q  r17, 8, r17 */
2931   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2932   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2933   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2934   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2935   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2936   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2937   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2938   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2939   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2940 };
2941
2942 /* Sebsequent entries in an absolute procedure linkage table look like
2943    this.  */
2944
2945 static const bfd_byte elf_sh64_plt_entry_be[PLT_ENTRY_SIZE] =
2946 {
2947   0xcc, 0x00, 0x01, 0x90, /* movi  nameN-in-GOT >> 48, r25 */
2948   0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 32) & 65535, r25 */
2949   0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 16) & 65535, r25 */
2950   0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
2951   0x8d, 0x90, 0x01, 0x90, /* ld.q  r25, 0, r25 */
2952   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2953   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2954   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2955   0xcc, 0x00, 0x01, 0x90, /* movi  (.+8-.PLT0) >> 16, r25 */
2956   0xc8, 0x00, 0x01, 0x90, /* shori (.+4-.PLT0) & 65535, r25 */
2957   0x6b, 0xf5, 0x66, 0x00, /* ptrel r25, tr0 */
2958   0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
2959   0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
2960   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2961   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2962   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2963 };
2964
2965 static const bfd_byte elf_sh64_plt_entry_le[PLT_ENTRY_SIZE] =
2966 {
2967   0x90, 0x01, 0x00, 0xcc, /* movi  nameN-in-GOT >> 16, r25 */
2968   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2969   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2970   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2971   0x90, 0x01, 0x90, 0x8d, /* ld.q  r25, 0, r25 */
2972   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2973   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2974   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2975   0x90, 0x01, 0x00, 0xcc, /* movi  (.+8-.PLT0) >> 16, r25 */
2976   0x90, 0x01, 0x00, 0xc8, /* shori (.+4-.PLT0) & 65535, r25 */
2977   0x00, 0x66, 0xf5, 0x6b, /* ptrel r25, tr0 */
2978   0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
2979   0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
2980   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2981   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2982   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2983 };
2984
2985 /* Entries in a PIC procedure linkage table look like this.  */
2986
2987 static const bfd_byte elf_sh64_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2988 {
2989   0xcc, 0x00, 0x01, 0x90, /* movi  nameN@GOT >> 16, r25 */
2990   0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
2991   0x40, 0xc3, 0x65, 0x90, /* ldx.q r12, r25, r25 */
2992   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2993   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2994   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2995   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2996   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2997   0xce, 0x00, 0x01, 0x10, /* movi  -GOT_BIAS, r17 */
2998   0x00, 0xc9, 0x45, 0x10, /* add   r12, r17, r17 */
2999   0x8d, 0x10, 0x09, 0x90, /* ld.q  r17, 16, r25 */
3000   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3001   0x8d, 0x10, 0x05, 0x10, /* ld.q  r17, 8, r17 */
3002   0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
3003   0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3004   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3005 };
3006
3007 static const bfd_byte elf_sh64_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3008 {
3009   0x90, 0x01, 0x00, 0xcc, /* movi  nameN@GOT >> 16, r25 */
3010   0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
3011   0x90, 0x65, 0xc3, 0x40, /* ldx.q r12, r25, r25 */
3012   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3013   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3014   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3015   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3016   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3017   0x10, 0x01, 0x00, 0xce, /* movi  -GOT_BIAS, r17 */
3018   0x10, 0x45, 0xc9, 0x00, /* add   r12, r17, r17 */
3019   0x90, 0x09, 0x10, 0x8d, /* ld.q  r17, 16, r25 */
3020   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3021   0x10, 0x05, 0x10, 0x8d, /* ld.q  r17, 8, r17 */
3022   0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
3023   0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3024   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3025 };
3026
3027 static const bfd_byte *elf_sh64_plt0_entry;
3028 static const bfd_byte *elf_sh64_plt_entry;
3029 static const bfd_byte *elf_sh64_pic_plt_entry;
3030
3031 /* Create an entry in an sh ELF linker hash table.  */
3032
3033 static struct bfd_hash_entry *
3034 sh64_elf64_link_hash_newfunc (struct bfd_hash_entry *entry,
3035                               struct bfd_hash_table *table,
3036                               const char *string)
3037 {
3038   struct elf_sh64_link_hash_entry *ret =
3039     (struct elf_sh64_link_hash_entry *) entry;
3040
3041   /* Allocate the structure if it has not already been allocated by a
3042      subclass.  */
3043   if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3044     ret = ((struct elf_sh64_link_hash_entry *)
3045            bfd_hash_allocate (table,
3046                               sizeof (struct elf_sh64_link_hash_entry)));
3047   if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3048     return (struct bfd_hash_entry *) ret;
3049
3050   /* Call the allocation method of the superclass.  */
3051   ret = ((struct elf_sh64_link_hash_entry *)
3052          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3053                                      table, string));
3054   if (ret != (struct elf_sh64_link_hash_entry *) NULL)
3055     {
3056       ret->pcrel_relocs_copied = NULL;
3057       ret->datalabel_got_offset = (bfd_vma) -1;
3058     }
3059
3060   return (struct bfd_hash_entry *) ret;
3061 }
3062
3063 /* Create an sh64 ELF linker hash table.  */
3064
3065 static struct bfd_link_hash_table *
3066 sh64_elf64_link_hash_table_create (bfd *abfd)
3067 {
3068   struct elf_link_hash_table *ret;
3069
3070   ret = (struct elf_link_hash_table *) bfd_malloc (sizeof (* ret));
3071   if (ret == (struct elf_link_hash_table *) NULL)
3072     return NULL;
3073
3074   if (!_bfd_elf_link_hash_table_init (ret, abfd,
3075                                       sh64_elf64_link_hash_newfunc,
3076                                       sizeof (struct elf_sh64_link_hash_entry),
3077                                       GENERIC_ELF_DATA))
3078     {
3079       free (ret);
3080       return NULL;
3081     }
3082
3083   return &ret->root;
3084 }
3085
3086 inline static void
3087 movi_shori_putval (bfd *output_bfd, unsigned long value, bfd_byte *addr)
3088 {
3089   bfd_put_32 (output_bfd,
3090               bfd_get_32 (output_bfd, addr)
3091               | ((value >> 6) & 0x3fffc00),
3092               addr);
3093   bfd_put_32 (output_bfd,
3094               bfd_get_32 (output_bfd, addr + 4)
3095               | ((value << 10) & 0x3fffc00),
3096               addr + 4);
3097 }
3098
3099 inline static void
3100 movi_3shori_putval (bfd *output_bfd, bfd_vma value, bfd_byte *addr)
3101 {
3102   bfd_put_32 (output_bfd,
3103               bfd_get_32 (output_bfd, addr)
3104               | ((value >> 38) & 0x3fffc00),
3105               addr);
3106   bfd_put_32 (output_bfd,
3107               bfd_get_32 (output_bfd, addr + 4)
3108               | ((value >> 22) & 0x3fffc00),
3109               addr + 4);
3110   bfd_put_32 (output_bfd,
3111               bfd_get_32 (output_bfd, addr + 8)
3112               | ((value >> 6) & 0x3fffc00),
3113               addr + 8);
3114   bfd_put_32 (output_bfd,
3115               bfd_get_32 (output_bfd, addr + 12)
3116               | ((value << 10) & 0x3fffc00),
3117               addr + 12);
3118 }
3119
3120 /* Create dynamic sections when linking against a dynamic object.  */
3121
3122 static bfd_boolean
3123 sh64_elf64_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3124 {
3125   flagword flags, pltflags;
3126   register asection *s;
3127   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3128   int ptralign = 0;
3129
3130   switch (bed->s->arch_size)
3131     {
3132     case 32:
3133       ptralign = 2;
3134       break;
3135
3136     case 64:
3137       ptralign = 3;
3138       break;
3139
3140     default:
3141       bfd_set_error (bfd_error_bad_value);
3142       return FALSE;
3143     }
3144
3145   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3146      .rel[a].bss sections.  */
3147
3148   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3149            | SEC_LINKER_CREATED);
3150
3151   pltflags = flags;
3152   pltflags |= SEC_CODE;
3153   if (bed->plt_not_loaded)
3154     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3155   if (bed->plt_readonly)
3156     pltflags |= SEC_READONLY;
3157
3158   s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
3159   if (s == NULL
3160       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3161     return FALSE;
3162
3163   if (bed->want_plt_sym)
3164     {
3165       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3166          .plt section.  */
3167       struct elf_link_hash_entry *h;
3168       struct bfd_link_hash_entry *bh = NULL;
3169
3170       if (! (_bfd_generic_link_add_one_symbol
3171              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3172               (bfd_vma) 0, (const char *) NULL, FALSE, bed->collect, &bh)))
3173         return FALSE;
3174
3175       h = (struct elf_link_hash_entry *) bh;
3176       h->def_regular = 1;
3177       h->type = STT_OBJECT;
3178       elf_hash_table (info)->hplt = h;
3179
3180       if (info->shared
3181           && ! bfd_elf_link_record_dynamic_symbol (info, h))
3182         return FALSE;
3183     }
3184
3185   s = bfd_make_section_with_flags (abfd,
3186                                    bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
3187                                    flags | SEC_READONLY);
3188   if (s == NULL
3189       || ! bfd_set_section_alignment (abfd, s, ptralign))
3190     return FALSE;
3191
3192   if (! _bfd_elf_create_got_section (abfd, info))
3193     return FALSE;
3194
3195   {
3196     const char *secname;
3197     char *relname;
3198     flagword secflags;
3199     asection *sec;
3200
3201     for (sec = abfd->sections; sec; sec = sec->next)
3202       {
3203         secflags = bfd_get_section_flags (abfd, sec);
3204         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3205             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3206           continue;
3207         secname = bfd_get_section_name (abfd, sec);
3208         relname = (char *) bfd_malloc (strlen (secname) + 6);
3209         strcpy (relname, ".rela");
3210         strcat (relname, secname);
3211         s = bfd_make_section_with_flags (abfd, relname,
3212                                          flags | SEC_READONLY);
3213         if (s == NULL
3214             || ! bfd_set_section_alignment (abfd, s, ptralign))
3215           return FALSE;
3216       }
3217   }
3218
3219   if (bed->want_dynbss)
3220     {
3221       /* The .dynbss section is a place to put symbols which are defined
3222          by dynamic objects, are referenced by regular objects, and are
3223          not functions.  We must allocate space for them in the process
3224          image and use a R_*_COPY reloc to tell the dynamic linker to
3225          initialize them at run time.  The linker script puts the .dynbss
3226          section into the .bss section of the final image.  */
3227       s = bfd_make_section_with_flags (abfd, ".dynbss",
3228                                        SEC_ALLOC | SEC_LINKER_CREATED);
3229       if (s == NULL)
3230         return FALSE;
3231
3232       /* The .rel[a].bss section holds copy relocs.  This section is not
3233          normally needed.  We need to create it here, though, so that the
3234          linker will map it to an output section.  We can't just create it
3235          only if we need it, because we will not know whether we need it
3236          until we have seen all the input files, and the first time the
3237          main linker code calls BFD after examining all the input files
3238          (size_dynamic_sections) the input sections have already been
3239          mapped to the output sections.  If the section turns out not to
3240          be needed, we can discard it later.  We will never need this
3241          section when generating a shared object, since they do not use
3242          copy relocs.  */
3243       if (! info->shared)
3244         {
3245           s = bfd_make_section_with_flags (abfd,
3246                                            (bed->default_use_rela_p
3247                                             ? ".rela.bss" : ".rel.bss"),
3248                                            flags | SEC_READONLY);
3249           if (s == NULL
3250               || ! bfd_set_section_alignment (abfd, s, ptralign))
3251             return FALSE;
3252         }
3253     }
3254
3255   return TRUE;
3256 }
3257 \f
3258 /* Adjust a symbol defined by a dynamic object and referenced by a
3259    regular object.  The current definition is in some section of the
3260    dynamic object, but we're not including those sections.  We have to
3261    change the definition to something the rest of the link can
3262    understand.  */
3263
3264 static bfd_boolean
3265 sh64_elf64_adjust_dynamic_symbol (struct bfd_link_info *info,
3266                                   struct elf_link_hash_entry *h)
3267 {
3268   bfd *dynobj;
3269   asection *s;
3270
3271   dynobj = elf_hash_table (info)->dynobj;
3272
3273   /* Make sure we know what is going on here.  */
3274   BFD_ASSERT (dynobj != NULL
3275               && (h->needs_plt
3276                   || h->u.weakdef != NULL
3277                   || (h->def_dynamic
3278                       && h->ref_regular
3279                       && !h->def_regular)));
3280
3281   /* If this is a function, put it in the procedure linkage table.  We
3282      will fill in the contents of the procedure linkage table later,
3283      when we know the address of the .got section.  */
3284   if (h->type == STT_FUNC
3285       || h->needs_plt)
3286     {
3287       if (! info->shared
3288           && !h->def_dynamic
3289           && !h->ref_dynamic)
3290         {
3291           /* This case can occur if we saw a PLT reloc in an input
3292              file, but the symbol was never referred to by a dynamic
3293              object.  In such a case, we don't actually need to build
3294              a procedure linkage table, and we can just do a REL64
3295              reloc instead.  */
3296           BFD_ASSERT (h->needs_plt);
3297           return TRUE;
3298         }
3299
3300       /* Make sure this symbol is output as a dynamic symbol.  */
3301       if (h->dynindx == -1)
3302         {
3303           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3304             return FALSE;
3305         }
3306
3307       s = bfd_get_section_by_name (dynobj, ".plt");
3308       BFD_ASSERT (s != NULL);
3309
3310       /* If this is the first .plt entry, make room for the special
3311          first entry.  */
3312       if (s->size == 0)
3313         s->size += PLT_ENTRY_SIZE;
3314
3315       /* If this symbol is not defined in a regular file, and we are
3316          not generating a shared library, then set the symbol to this
3317          location in the .plt.  This is required to make function
3318          pointers compare as equal between the normal executable and
3319          the shared library.  */
3320       if (! info->shared
3321           && !h->def_regular)
3322         {
3323           h->root.u.def.section = s;
3324           h->root.u.def.value = s->size;
3325         }
3326
3327       h->plt.offset = s->size;
3328
3329       /* Make room for this entry.  */
3330       s->size += elf_sh64_sizeof_plt (info);
3331
3332       /* We also need to make an entry in the .got.plt section, which
3333          will be placed in the .got section by the linker script.  */
3334
3335       s = bfd_get_section_by_name (dynobj, ".got.plt");
3336       BFD_ASSERT (s != NULL);
3337       s->size += 8;
3338
3339       /* We also need to make an entry in the .rela.plt section.  */
3340
3341       s = bfd_get_section_by_name (dynobj, ".rela.plt");
3342       BFD_ASSERT (s != NULL);
3343       s->size += sizeof (Elf64_External_Rela);
3344
3345       return TRUE;
3346     }
3347
3348   /* If this is a weak symbol, and there is a real definition, the
3349      processor independent code will have arranged for us to see the
3350      real definition first, and we can just use the same value.  */
3351   if (h->u.weakdef != NULL)
3352     {
3353       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3354                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
3355       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3356       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3357       return TRUE;
3358     }
3359
3360   /* This is a reference to a symbol defined by a dynamic object which
3361      is not a function.  */
3362
3363   /* If we are creating a shared library, we must presume that the
3364      only references to the symbol are via the global offset table.
3365      For such cases we need not do anything here; the relocations will
3366      be handled correctly by relocate_section.  */
3367   if (info->shared)
3368     return TRUE;
3369
3370   /* If there are no references to this symbol that do not use the
3371      GOT, we don't need to generate a copy reloc.  */
3372   if (!h->non_got_ref)
3373     return TRUE;
3374
3375   if (h->size == 0)
3376     {
3377       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
3378                              h->root.root.string);
3379       return TRUE;
3380     }
3381
3382   /* We must allocate the symbol in our .dynbss section, which will
3383      become part of the .bss section of the executable.  There will be
3384      an entry for this symbol in the .dynsym section.  The dynamic
3385      object will contain position independent code, so all references
3386      from the dynamic object to this symbol will go through the global
3387      offset table.  The dynamic linker will use the .dynsym entry to
3388      determine the address it must put in the global offset table, so
3389      both the dynamic object and the regular object will refer to the
3390      same memory location for the variable.  */
3391
3392   s = bfd_get_section_by_name (dynobj, ".dynbss");
3393   BFD_ASSERT (s != NULL);
3394
3395   /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
3396      copy the initial value out of the dynamic object and into the
3397      runtime process image.  We need to remember the offset into the
3398      .rela.bss section we are going to use.  */
3399   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3400     {
3401       asection *srel;
3402
3403       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
3404       BFD_ASSERT (srel != NULL);
3405       srel->size += sizeof (Elf64_External_Rela);
3406       h->needs_copy = 1;
3407     }
3408
3409   return _bfd_elf_adjust_dynamic_copy (h, s);
3410 }
3411
3412 /* This function is called via sh_elf_link_hash_traverse if we are
3413    creating a shared object with -Bsymbolic.  It discards the space
3414    allocated to copy PC relative relocs against symbols which are
3415    defined in regular objects.  We allocated space for them in the
3416    check_relocs routine, but we won't fill them in in the
3417    relocate_section routine.  */
3418
3419 static bfd_boolean
3420 sh64_elf64_discard_copies (struct elf_sh64_link_hash_entry *h,
3421                            void *ignore ATTRIBUTE_UNUSED)
3422 {
3423   struct elf_sh64_pcrel_relocs_copied *s;
3424
3425   if (h->root.root.type == bfd_link_hash_warning)
3426     h = (struct elf_sh64_link_hash_entry *) h->root.root.u.i.link;
3427
3428   /* We only discard relocs for symbols defined in a regular object.  */
3429   if (!h->root.def_regular)
3430     return TRUE;
3431
3432   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3433     s->section->size -= s->count * sizeof (Elf64_External_Rela);
3434
3435   return TRUE;
3436 }
3437
3438 /* Set the sizes of the dynamic sections.  */
3439
3440 static bfd_boolean
3441 sh64_elf64_size_dynamic_sections (bfd *output_bfd,
3442                                   struct bfd_link_info *info)
3443 {
3444   bfd *dynobj;
3445   asection *s;
3446   bfd_boolean plt;
3447   bfd_boolean relocs;
3448   bfd_boolean reltext;
3449
3450   dynobj = elf_hash_table (info)->dynobj;
3451   BFD_ASSERT (dynobj != NULL);
3452
3453   if (elf_hash_table (info)->dynamic_sections_created)
3454     {
3455       /* Set the contents of the .interp section to the interpreter.  */
3456       if (info->executable)
3457         {
3458           s = bfd_get_section_by_name (dynobj, ".interp");
3459           BFD_ASSERT (s != NULL);
3460           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3461           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3462         }
3463     }
3464   else
3465     {
3466       /* We may have created entries in the .rela.got section.
3467          However, if we are not creating the dynamic sections, we will
3468          not actually use these entries.  Reset the size of .rela.got,
3469          which will cause it to get stripped from the output file
3470          below.  */
3471       s = bfd_get_section_by_name (dynobj, ".rela.got");
3472       if (s != NULL)
3473         s->size = 0;
3474     }
3475
3476   /* If this is a -Bsymbolic shared link, then we need to discard all
3477      PC relative relocs against symbols defined in a regular object.
3478      We allocated space for them in the check_relocs routine, but we
3479      will not fill them in in the relocate_section routine.  */
3480   if (info->shared && info->symbolic)
3481     sh64_elf64_link_hash_traverse (elf_hash_table (info),
3482                                    sh64_elf64_discard_copies, NULL);
3483
3484   /* The check_relocs and adjust_dynamic_symbol entry points have
3485      determined the sizes of the various dynamic sections.  Allocate
3486      memory for them.  */
3487   plt = FALSE;
3488   relocs = FALSE;
3489   reltext = FALSE;
3490   for (s = dynobj->sections; s != NULL; s = s->next)
3491     {
3492       const char *name;
3493
3494       if ((s->flags & SEC_LINKER_CREATED) == 0)
3495         continue;
3496
3497       /* It's OK to base decisions on the section name, because none
3498          of the dynobj section names depend upon the input files.  */
3499       name = bfd_get_section_name (dynobj, s);
3500
3501       if (strcmp (name, ".plt") == 0)
3502         {
3503           /* Remember whether there is a PLT.  */
3504           plt = s->size != 0;
3505         }
3506       else if (CONST_STRNEQ (name, ".rela"))
3507         {
3508           if (s->size != 0)
3509             {
3510               asection *target;
3511
3512               /* Remember whether there are any reloc sections other
3513                  than .rela.plt.  */
3514               if (strcmp (name, ".rela.plt") != 0)
3515                 {
3516                   const char *outname;
3517
3518                   relocs = TRUE;
3519
3520                   /* If this relocation section applies to a read only
3521                      section, then we probably need a DT_TEXTREL
3522                      entry.  The entries in the .rela.plt section
3523                      really apply to the .got section, which we
3524                      created ourselves and so know is not readonly.  */
3525                   outname = bfd_get_section_name (output_bfd,
3526                                                   s->output_section);
3527                   target = bfd_get_section_by_name (output_bfd, outname + 5);
3528                   if (target != NULL
3529                       && (target->flags & SEC_READONLY) != 0
3530                       && (target->flags & SEC_ALLOC) != 0)
3531                     reltext = TRUE;
3532                 }
3533
3534               /* We use the reloc_count field as a counter if we need
3535                  to copy relocs into the output file.  */
3536               s->reloc_count = 0;
3537             }
3538         }
3539       else if (! CONST_STRNEQ (name, ".got")
3540                && strcmp (name, ".dynbss") != 0)
3541         {
3542           /* It's not one of our sections, so don't allocate space.  */
3543           continue;
3544         }
3545
3546       if (s->size == 0)
3547         {
3548           /* If we don't need this section, strip it from the
3549              output file.  This is mostly to handle .rela.bss and
3550              .rela.plt.  We must create both sections in
3551              create_dynamic_sections, because they must be created
3552              before the linker maps input sections to output
3553              sections.  The linker does that before
3554              adjust_dynamic_symbol is called, and it is that
3555              function which decides whether anything needs to go
3556              into these sections.  */
3557           s->flags |= SEC_EXCLUDE;
3558           continue;
3559         }
3560
3561       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3562         continue;
3563
3564       /* Allocate memory for the section contents.  */
3565       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3566       if (s->contents == NULL)
3567         return FALSE;
3568     }
3569
3570   if (elf_hash_table (info)->dynamic_sections_created)
3571     {
3572       /* Add some entries to the .dynamic section.  We fill in the
3573          values later, in sh64_elf64_finish_dynamic_sections, but we
3574          must add the entries now so that we get the correct size for
3575          the .dynamic section.  The DT_DEBUG entry is filled in by the
3576          dynamic linker and used by the debugger.  */
3577       if (info->executable)
3578         {
3579           if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
3580             return FALSE;
3581         }
3582
3583       if (plt)
3584         {
3585           if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
3586               || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3587               || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3588               || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
3589             return FALSE;
3590         }
3591
3592       if (relocs)
3593         {
3594           if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
3595               || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
3596               || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
3597                                               sizeof (Elf64_External_Rela)))
3598             return FALSE;
3599         }
3600
3601       if (reltext)
3602         {
3603           if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
3604             return FALSE;
3605         }
3606     }
3607
3608   return TRUE;
3609 }
3610
3611 /* Finish up dynamic symbol handling.  We set the contents of various
3612    dynamic sections here.  */
3613
3614 static bfd_boolean
3615 sh64_elf64_finish_dynamic_symbol (bfd *output_bfd,
3616                                   struct bfd_link_info *info,
3617                                   struct elf_link_hash_entry *h,
3618                                   Elf_Internal_Sym *sym)
3619 {
3620   bfd *dynobj;
3621
3622   dynobj = elf_hash_table (info)->dynobj;
3623
3624   if (h->plt.offset != (bfd_vma) -1)
3625     {
3626       asection *splt;
3627       asection *sgot;
3628       asection *srel;
3629
3630       bfd_vma plt_index;
3631       bfd_vma got_offset;
3632       Elf_Internal_Rela rel;
3633       bfd_byte *loc;
3634
3635       /* This symbol has an entry in the procedure linkage table.  Set
3636          it up.  */
3637
3638       BFD_ASSERT (h->dynindx != -1);
3639
3640       splt = bfd_get_section_by_name (dynobj, ".plt");
3641       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3642       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3643       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3644
3645       /* Get the index in the procedure linkage table which
3646          corresponds to this symbol.  This is the index of this symbol
3647          in all the symbols for which we are making plt entries.  The
3648          first entry in the procedure linkage table is reserved.  */
3649       plt_index = h->plt.offset / elf_sh64_sizeof_plt (info) - 1;
3650
3651       /* Get the offset into the .got table of the entry that
3652          corresponds to this function.  Each .got entry is 8 bytes.
3653          The first three are reserved.  */
3654       got_offset = (plt_index + 3) * 8;
3655
3656       if (info->shared)
3657         got_offset -= GOT_BIAS;
3658
3659       /* Fill in the entry in the procedure linkage table.  */
3660       if (! info->shared)
3661         {
3662           if (elf_sh64_plt_entry == NULL)
3663             {
3664               elf_sh64_plt_entry = (bfd_big_endian (output_bfd) ?
3665                                   elf_sh64_plt_entry_be : elf_sh64_plt_entry_le);
3666             }
3667           memcpy (splt->contents + h->plt.offset, elf_sh64_plt_entry,
3668                   elf_sh64_sizeof_plt (info));
3669           movi_3shori_putval (output_bfd,
3670                               (sgot->output_section->vma
3671                                + sgot->output_offset
3672                                + got_offset),
3673                               (splt->contents + h->plt.offset
3674                                + elf_sh64_plt_symbol_offset (info)));
3675
3676           /* Set bottom bit because its for a branch to SHmedia */
3677           movi_shori_putval (output_bfd,
3678                              -(h->plt.offset
3679                               + elf_sh64_plt_plt0_offset (info) + 8)
3680                              | 1,
3681                              (splt->contents + h->plt.offset
3682                               + elf_sh64_plt_plt0_offset (info)));
3683         }
3684       else
3685         {
3686           if (elf_sh64_pic_plt_entry == NULL)
3687             {
3688               elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3689                                       elf_sh64_pic_plt_entry_be :
3690                                       elf_sh64_pic_plt_entry_le);
3691             }
3692           memcpy (splt->contents + h->plt.offset, elf_sh64_pic_plt_entry,
3693                   elf_sh64_sizeof_plt (info));
3694           movi_shori_putval (output_bfd, got_offset,
3695                              (splt->contents + h->plt.offset
3696                               + elf_sh64_plt_symbol_offset (info)));
3697         }
3698
3699       if (info->shared)
3700         got_offset += GOT_BIAS;
3701
3702       movi_shori_putval (output_bfd,
3703                          plt_index * sizeof (Elf64_External_Rela),
3704                          (splt->contents + h->plt.offset
3705                           + elf_sh64_plt_reloc_offset (info)));
3706
3707       /* Fill in the entry in the global offset table.  */
3708       bfd_put_64 (output_bfd,
3709                   (splt->output_section->vma
3710                    + splt->output_offset
3711                    + h->plt.offset
3712                    + elf_sh64_plt_temp_offset (info)),
3713                   sgot->contents + got_offset);
3714
3715       /* Fill in the entry in the .rela.plt section.  */
3716       rel.r_offset = (sgot->output_section->vma
3717                       + sgot->output_offset
3718                       + got_offset);
3719       rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_JMP_SLOT64);
3720       rel.r_addend = 0;
3721       rel.r_addend = GOT_BIAS;
3722       loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
3723       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3724
3725       if (!h->def_regular)
3726         {
3727           /* Mark the symbol as undefined, rather than as defined in
3728              the .plt section.  Leave the value alone.  */
3729           sym->st_shndx = SHN_UNDEF;
3730         }
3731     }
3732
3733   if (h->got.offset != (bfd_vma) -1)
3734     {
3735       asection *sgot;
3736       asection *srel;
3737       Elf_Internal_Rela rel;
3738       bfd_byte *loc;
3739
3740       /* This symbol has an entry in the global offset table.  Set it
3741          up.  */
3742
3743       sgot = bfd_get_section_by_name (dynobj, ".got");
3744       srel = bfd_get_section_by_name (dynobj, ".rela.got");
3745       BFD_ASSERT (sgot != NULL && srel != NULL);
3746
3747       rel.r_offset = (sgot->output_section->vma
3748                       + sgot->output_offset
3749                       + (h->got.offset &~ 1));
3750
3751       /* If this is a -Bsymbolic link, and the symbol is defined
3752          locally, we just want to emit a RELATIVE reloc.  Likewise if
3753          the symbol was forced to be local because of a version file.
3754          The entry in the global offset table will already have been
3755          initialized in the relocate_section function.  */
3756       if (info->shared
3757           && (info->symbolic || h->dynindx == -1)
3758           && h->def_regular)
3759         {
3760           rel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
3761           rel.r_addend = (h->root.u.def.value
3762                           + h->root.u.def.section->output_section->vma
3763                           + h->root.u.def.section->output_offset);
3764         }
3765       else
3766         {
3767           bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3768           rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_GLOB_DAT64);
3769           rel.r_addend = 0;
3770         }
3771
3772       loc = srel->contents;
3773       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
3774       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3775     }
3776
3777   if (h->needs_copy)
3778     {
3779       asection *s;
3780       Elf_Internal_Rela rel;
3781       bfd_byte *loc;
3782
3783       /* This symbol needs a copy reloc.  Set it up.  */
3784
3785       BFD_ASSERT (h->dynindx != -1
3786                   && (h->root.type == bfd_link_hash_defined
3787                       || h->root.type == bfd_link_hash_defweak));
3788
3789       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3790                                    ".rela.bss");
3791       BFD_ASSERT (s != NULL);
3792
3793       rel.r_offset = (h->root.u.def.value
3794                       + h->root.u.def.section->output_section->vma
3795                       + h->root.u.def.section->output_offset);
3796       rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_COPY64);
3797       rel.r_addend = 0;
3798       loc = s->contents;
3799       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
3800       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3801     }
3802
3803   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3804   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3805       || h == elf_hash_table (info)->hgot)
3806     sym->st_shndx = SHN_ABS;
3807
3808   return TRUE;
3809 }
3810
3811 /* Finish up the dynamic sections.  */
3812
3813 static bfd_boolean
3814 sh64_elf64_finish_dynamic_sections (bfd *output_bfd,
3815                                     struct bfd_link_info *info)
3816 {
3817   bfd *dynobj;
3818   asection *sgot;
3819   asection *sdyn;
3820
3821   dynobj = elf_hash_table (info)->dynobj;
3822
3823   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3824   BFD_ASSERT (sgot != NULL);
3825   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3826
3827   if (elf_hash_table (info)->dynamic_sections_created)
3828     {
3829       asection *splt;
3830       Elf64_External_Dyn *dyncon, *dynconend;
3831
3832       BFD_ASSERT (sdyn != NULL);
3833
3834       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3835       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3836       for (; dyncon < dynconend; dyncon++)
3837         {
3838           Elf_Internal_Dyn dyn;
3839           const char *name;
3840           asection *s;
3841           struct elf_link_hash_entry *h;
3842
3843           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3844
3845           switch (dyn.d_tag)
3846             {
3847             default:
3848               break;
3849
3850             case DT_INIT:
3851               name = info->init_function;
3852               goto get_sym;
3853
3854             case DT_FINI:
3855               name = info->fini_function;
3856             get_sym:
3857               if (dyn.d_un.d_val != 0)
3858                 {
3859                   h = elf_link_hash_lookup (elf_hash_table (info), name,
3860                                             FALSE, FALSE, TRUE);
3861                   if (h != NULL && (h->other & STO_SH5_ISA32))
3862                     {
3863                       dyn.d_un.d_val |= 1;
3864                       bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3865                     }
3866                 }
3867               break;
3868
3869             case DT_PLTGOT:
3870               name = ".got";
3871               goto get_vma;
3872
3873             case DT_JMPREL:
3874               name = ".rela.plt";
3875             get_vma:
3876               s = bfd_get_section_by_name (output_bfd, name);
3877               BFD_ASSERT (s != NULL);
3878               dyn.d_un.d_ptr = s->vma;
3879               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3880               break;
3881
3882             case DT_PLTRELSZ:
3883               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3884               BFD_ASSERT (s != NULL);
3885               dyn.d_un.d_val = s->size;
3886               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3887               break;
3888
3889             case DT_RELASZ:
3890               /* My reading of the SVR4 ABI indicates that the
3891                  procedure linkage table relocs (DT_JMPREL) should be
3892                  included in the overall relocs (DT_RELA).  This is
3893                  what Solaris does.  However, UnixWare can not handle
3894                  that case.  Therefore, we override the DT_RELASZ entry
3895                  here to make it not include the JMPREL relocs.  Since
3896                  the linker script arranges for .rela.plt to follow all
3897                  other relocation sections, we don't have to worry
3898                  about changing the DT_RELA entry.  */
3899               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3900               if (s != NULL)
3901                 dyn.d_un.d_val -= s->size;
3902               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3903               break;
3904             }
3905         }
3906
3907       /* Fill in the first entry in the procedure linkage table.  */
3908       splt = bfd_get_section_by_name (dynobj, ".plt");
3909       if (splt && splt->size > 0)
3910         {
3911           if (info->shared)
3912             {
3913               if (elf_sh64_pic_plt_entry == NULL)
3914                 {
3915                   elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3916                                           elf_sh64_pic_plt_entry_be :
3917                                           elf_sh64_pic_plt_entry_le);
3918                 }
3919               memcpy (splt->contents, elf_sh64_pic_plt_entry,
3920                       elf_sh64_sizeof_plt (info));
3921             }
3922           else
3923             {
3924               if (elf_sh64_plt0_entry == NULL)
3925                 {
3926                   elf_sh64_plt0_entry = (bfd_big_endian (output_bfd) ?
3927                                        elf_sh64_plt0_entry_be :
3928                                        elf_sh64_plt0_entry_le);
3929                 }
3930               memcpy (splt->contents, elf_sh64_plt0_entry, PLT_ENTRY_SIZE);
3931               movi_3shori_putval (output_bfd,
3932                                   sgot->output_section->vma
3933                                   + sgot->output_offset,
3934                                   splt->contents
3935                                   + elf_sh64_plt0_gotplt_offset (info));
3936             }
3937
3938           /* UnixWare sets the entsize of .plt to 8, although that doesn't
3939              really seem like the right value.  */
3940           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 8;
3941         }
3942     }
3943
3944   /* Fill in the first three entries in the global offset table.  */
3945   if (sgot->size > 0)
3946     {
3947       if (sdyn == NULL)
3948         bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
3949       else
3950         bfd_put_64 (output_bfd,
3951                     sdyn->output_section->vma + sdyn->output_offset,
3952                     sgot->contents);
3953       bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3954       bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 16);
3955     }
3956
3957   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
3958
3959   return TRUE;
3960 }
3961
3962 /* Merge non visibility st_other attribute when the symbol comes from
3963    a dynamic object.  */
3964 static void
3965 sh64_elf64_merge_symbol_attribute (struct elf_link_hash_entry *h,
3966                                    const Elf_Internal_Sym *isym,
3967                                    bfd_boolean definition,
3968                                    bfd_boolean dynamic ATTRIBUTE_UNUSED)
3969 {
3970   if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
3971     {
3972       unsigned char other;
3973
3974       /* Take the balance of OTHER from the definition.  */
3975       other = (definition ? isym->st_other : h->other);
3976       other &= ~ ELF_ST_VISIBILITY (-1);
3977       h->other = other | ELF_ST_VISIBILITY (h->other);
3978     }
3979
3980   return;
3981 }
3982
3983 static const struct bfd_elf_special_section sh64_elf64_special_sections[]=
3984 {
3985   { STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 },
3986   { NULL,                       0, 0, 0,            0 }
3987 };
3988
3989 #define TARGET_BIG_SYM          bfd_elf64_sh64_vec
3990 #define TARGET_BIG_NAME         "elf64-sh64"
3991 #define TARGET_LITTLE_SYM       bfd_elf64_sh64l_vec
3992 #define TARGET_LITTLE_NAME      "elf64-sh64l"
3993 #define ELF_ARCH                bfd_arch_sh
3994 #define ELF_MACHINE_CODE        EM_SH
3995 #define ELF_MAXPAGESIZE         128
3996
3997 #define elf_symbol_leading_char '_'
3998
3999 #define bfd_elf64_bfd_reloc_type_lookup sh_elf64_reloc_type_lookup
4000 #define bfd_elf64_bfd_reloc_name_lookup \
4001                                         sh_elf64_reloc_name_lookup
4002 #define elf_info_to_howto               sh_elf64_info_to_howto
4003
4004 /* Note: there's no relaxation at present.  */
4005
4006 #define elf_backend_relocate_section    sh_elf64_relocate_section
4007 #define bfd_elf64_bfd_get_relocated_section_contents \
4008                                         sh_elf64_get_relocated_section_contents
4009 #define elf_backend_object_p            sh_elf64_set_mach_from_flags
4010 #define bfd_elf64_bfd_set_private_flags \
4011                                         sh_elf64_set_private_flags
4012 #define bfd_elf64_bfd_copy_private_bfd_data \
4013                                         sh_elf64_copy_private_data
4014 #define bfd_elf64_bfd_merge_private_bfd_data \
4015                                         sh_elf64_merge_private_data
4016 #define elf_backend_fake_sections       sh64_elf64_fake_sections
4017
4018 #define elf_backend_gc_mark_hook        sh_elf64_gc_mark_hook
4019 #define elf_backend_check_relocs        sh_elf64_check_relocs
4020
4021 #define elf_backend_can_gc_sections     1
4022
4023 #define elf_backend_get_symbol_type     sh64_elf64_get_symbol_type
4024
4025 #define elf_backend_add_symbol_hook     sh64_elf64_add_symbol_hook
4026
4027 #define elf_backend_link_output_symbol_hook \
4028         sh64_elf64_link_output_symbol_hook
4029
4030 #define elf_backend_merge_symbol_attribute \
4031         sh64_elf64_merge_symbol_attribute
4032
4033 #define elf_backend_final_write_processing \
4034         sh64_elf64_final_write_processing
4035
4036 #define elf_backend_create_dynamic_sections \
4037                                         sh64_elf64_create_dynamic_sections
4038 #define bfd_elf64_bfd_link_hash_table_create \
4039                                         sh64_elf64_link_hash_table_create
4040 #define elf_backend_adjust_dynamic_symbol \
4041                                         sh64_elf64_adjust_dynamic_symbol
4042 #define elf_backend_size_dynamic_sections \
4043                                         sh64_elf64_size_dynamic_sections
4044 #define elf_backend_omit_section_dynsym \
4045   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4046 #define elf_backend_finish_dynamic_symbol \
4047                                         sh64_elf64_finish_dynamic_symbol
4048 #define elf_backend_finish_dynamic_sections \
4049                                         sh64_elf64_finish_dynamic_sections
4050 #define elf_backend_special_sections    sh64_elf64_special_sections
4051
4052 #define elf_backend_want_got_plt        1
4053 #define elf_backend_plt_readonly        1
4054 #define elf_backend_want_plt_sym        0
4055 #define elf_backend_got_header_size     24
4056
4057 #include "elf64-target.h"
4058
4059 /* NetBSD support.  */
4060 #undef  TARGET_BIG_SYM
4061 #define TARGET_BIG_SYM                  bfd_elf64_sh64nbsd_vec
4062 #undef  TARGET_BIG_NAME
4063 #define TARGET_BIG_NAME                 "elf64-sh64-nbsd"
4064 #undef  TARGET_LITTLE_SYM
4065 #define TARGET_LITTLE_SYM               bfd_elf64_sh64lnbsd_vec
4066 #undef  TARGET_LITTLE_NAME
4067 #define TARGET_LITTLE_NAME              "elf64-sh64l-nbsd"
4068 #undef  ELF_MAXPAGESIZE
4069 #define ELF_MAXPAGESIZE                 0x10000
4070 #undef  elf_symbol_leading_char
4071 #define elf_symbol_leading_char         0
4072
4073 #define elf64_bed                       elf64_sh64_nbsd_bed
4074
4075 #include "elf64-target.h"
4076
4077 /* Linux support.  */
4078 #undef  TARGET_BIG_SYM
4079 #define TARGET_BIG_SYM                  bfd_elf64_sh64blin_vec
4080 #undef  TARGET_BIG_NAME
4081 #define TARGET_BIG_NAME                 "elf64-sh64big-linux"
4082 #undef  TARGET_LITTLE_SYM
4083 #define TARGET_LITTLE_SYM               bfd_elf64_sh64lin_vec
4084 #undef  TARGET_LITTLE_NAME
4085 #define TARGET_LITTLE_NAME              "elf64-sh64-linux"
4086 #undef elf64_bed
4087 #define elf64_bed                       elf64_sh64_linux_bed
4088
4089 #include "elf64-target.h"