bfd/elf64-sh64.c

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