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 *dynobj;
1436   bfd_vma *local_got_offsets;
1437   asection *sgot;
1438   asection *sgotplt;
1439   asection *splt;
1440   asection *sreloc;
1441   bfd_vma disp, dropped;
1442
1443   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1444   sym_hashes = elf_sym_hashes (input_bfd);
1445   dynobj = elf_hash_table (info)->dynobj;
1446   local_got_offsets = elf_local_got_offsets (input_bfd);
1447
1448   sgot = NULL;
1449   sgotplt = NULL;
1450   splt = NULL;
1451   sreloc = NULL;
1452
1453   rel = relocs;
1454   relend = relocs + input_section->reloc_count;
1455   for (; rel < relend; rel++)
1456     {
1457       int r_type;
1458       reloc_howto_type *howto;
1459       unsigned long r_symndx;
1460       Elf_Internal_Sym *sym;
1461       asection *sec;
1462       struct elf_link_hash_entry *h;
1463       bfd_vma relocation;
1464       bfd_vma addend = (bfd_vma)0;
1465       bfd_reloc_status_type r;
1466       int seen_stt_datalabel = 0;
1467
1468       r_symndx = ELF64_R_SYM (rel->r_info);
1469
1470       r_type = ELF64_R_TYPE (rel->r_info);
1471
1472       if (r_type == (int) R_SH_NONE)
1473         continue;
1474
1475       if (r_type < 0
1476           || r_type > R_SH_64_PCREL
1477           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
1478               && r_type <= (int) R_SH_LAST_INVALID_RELOC)
1479           || (r_type >= (int) R_SH_DIR8WPN
1480               && r_type <= (int) R_SH_LAST_INVALID_RELOC)
1481           || (r_type >= (int) R_SH_GNU_VTINHERIT
1482               && r_type <= (int) R_SH_PSHL)
1483           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
1484               && r_type <= R_SH_GOTPLT32)
1485           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
1486               && r_type <= (int) R_SH_LAST_INVALID_RELOC_4))
1487         {
1488           bfd_set_error (bfd_error_bad_value);
1489           return FALSE;
1490         }
1491
1492       howto = sh_elf64_howto_table + r_type;
1493
1494       h = NULL;
1495       sym = NULL;
1496       sec = NULL;
1497       relocation = 0;
1498       if (r_symndx < symtab_hdr->sh_info)
1499         {
1500           sym = local_syms + r_symndx;
1501           sec = local_sections[r_symndx];
1502           relocation = ((sec->output_section->vma
1503                          + sec->output_offset
1504                          + sym->st_value)
1505                         | ((sym->st_other & STO_SH5_ISA32) != 0));
1506
1507           /* A local symbol never has STO_SH5_ISA32, so we don't need
1508              datalabel processing here.  Make sure this does not change
1509              without notice.  */
1510           if ((sym->st_other & STO_SH5_ISA32) != 0)
1511             (*info->callbacks->reloc_dangerous)
1512               (info,
1513                _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
1514                input_bfd, input_section, rel->r_offset);
1515
1516           if (sec != NULL && discarded_section (sec))
1517             /* Handled below.  */
1518             ;
1519           else if (bfd_link_relocatable (info))
1520             {
1521               /* This is a relocatable link.  We don't have to change
1522                  anything, unless the reloc is against a section symbol,
1523                  in which case we have to adjust according to where the
1524                  section symbol winds up in the output section.  */
1525               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1526                 goto final_link_relocate;
1527
1528               continue;
1529             }
1530           else if (! howto->partial_inplace)
1531             {
1532               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1533               relocation |= ((sym->st_other & STO_SH5_ISA32) != 0);
1534             }
1535           else if ((sec->flags & SEC_MERGE)
1536                    && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1537             {
1538               asection *msec;
1539
1540               if (howto->rightshift || howto->src_mask != 0xffffffff)
1541                 {
1542                   (*_bfd_error_handler)
1543                     (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
1544                      input_bfd, input_section,
1545                      (long) rel->r_offset, howto->name);
1546                   return FALSE;
1547                 }
1548
1549               addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
1550               msec = sec;
1551               addend =
1552                 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1553                 - relocation;
1554               addend += msec->output_section->vma + msec->output_offset;
1555               bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
1556               addend = 0;
1557             }
1558         }
1559       else
1560         {
1561           /* ??? Could we use the RELOC_FOR_GLOBAL_SYMBOL macro here ?  */
1562
1563           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1564           while (h->root.type == bfd_link_hash_indirect
1565                  || h->root.type == bfd_link_hash_warning)
1566             {
1567               /* If the reference passes a symbol marked with
1568                  STT_DATALABEL, then any STO_SH5_ISA32 on the final value
1569                  doesn't count.  */
1570               seen_stt_datalabel |= h->type == STT_DATALABEL;
1571               h = (struct elf_link_hash_entry *) h->root.u.i.link;
1572             }
1573
1574           if (h->root.type == bfd_link_hash_defined
1575               || h->root.type == bfd_link_hash_defweak)
1576             {
1577               sec = h->root.u.def.section;
1578               /* In these cases, we don't need the relocation value.
1579                  We check specially because in some obscure cases
1580                  sec->output_section will be NULL.  */
1581               if (r_type == R_SH_GOTPC_LOW16
1582                   || r_type == R_SH_GOTPC_MEDLOW16
1583                   || r_type == R_SH_GOTPC_MEDHI16
1584                   || r_type == R_SH_GOTPC_HI16
1585                   || ((r_type == R_SH_PLT_LOW16
1586                        || r_type == R_SH_PLT_MEDLOW16
1587                        || r_type == R_SH_PLT_MEDHI16
1588                        || r_type == R_SH_PLT_HI16)
1589                       && h->plt.offset != (bfd_vma) -1)
1590                   || ((r_type == R_SH_GOT_LOW16
1591                        || r_type == R_SH_GOT_MEDLOW16
1592                        || r_type == R_SH_GOT_MEDHI16
1593                        || r_type == R_SH_GOT_HI16)
1594                       && elf_hash_table (info)->dynamic_sections_created
1595                       && (! bfd_link_pic (info)
1596                           || (! info->symbolic && h->dynindx != -1)
1597                           || !h->def_regular))
1598                   /* The cases above are those in which relocation is
1599                      overwritten in the switch block below.  The cases
1600                      below are those in which we must defer relocation
1601                      to run-time, because we can't resolve absolute
1602                      addresses when creating a shared library.  */
1603                   || (bfd_link_pic (info)
1604                       && ((! info->symbolic && h->dynindx != -1)
1605                           || !h->def_regular)
1606                       && ((r_type == R_SH_64
1607                            && !(ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1608                                 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN))
1609                           || r_type == R_SH_64_PCREL)
1610                       && ((input_section->flags & SEC_ALLOC) != 0
1611                           /* DWARF will emit R_SH_DIR32 relocations in its
1612                              sections against symbols defined externally
1613                              in shared libraries.  We can't do anything
1614                              with them here.  */
1615                           || (input_section->flags & SEC_DEBUGGING) != 0))
1616                   /* Dynamic relocs are not propagated for SEC_DEBUGGING
1617                      sections because such sections are not SEC_ALLOC and
1618                      thus ld.so will not process them.  */
1619                   || (sec->output_section == NULL
1620                       && ((input_section->flags & SEC_DEBUGGING) != 0
1621                           && h->def_dynamic)))
1622                 ;
1623               else if (sec->output_section != NULL)
1624                 relocation = ((h->root.u.def.value
1625                                + sec->output_section->vma
1626                                + sec->output_offset)
1627                               /* A STO_SH5_ISA32 causes a "bitor 1" to the
1628                                  symbol value, unless we've seen
1629                                  STT_DATALABEL on the way to it.  */
1630                               | ((h->other & STO_SH5_ISA32) != 0
1631                                  && ! seen_stt_datalabel));
1632               else if (!bfd_link_relocatable (info)
1633                        && (_bfd_elf_section_offset (output_bfd, info,
1634                                                     input_section,
1635                                                     rel->r_offset)
1636                            != (bfd_vma) -1))
1637                 {
1638                   (*_bfd_error_handler)
1639                     (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1640                      input_bfd,
1641                      input_section,
1642                      (long) rel->r_offset,
1643                      howto->name,
1644                      h->root.root.string);
1645                 }
1646             }
1647           else if (h->root.type == bfd_link_hash_undefweak)
1648             ;
1649           else if (info->unresolved_syms_in_objects == RM_IGNORE
1650                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1651             ;
1652           else if (!bfd_link_relocatable (info))
1653             (*info->callbacks->undefined_symbol)
1654               (info, h->root.root.string, input_bfd,
1655                input_section, rel->r_offset,
1656                (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1657                 || ELF_ST_VISIBILITY (h->other)));
1658         }
1659
1660       if (sec != NULL && discarded_section (sec))
1661         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1662                                          rel, 1, relend, howto, 0, contents);
1663
1664       if (bfd_link_relocatable (info))
1665         continue;
1666
1667       disp = (relocation
1668               - input_section->output_section->vma
1669               - input_section->output_offset
1670               - rel->r_offset);
1671       dropped = 0;
1672       switch ((int)r_type)
1673         {
1674         case R_SH_PT_16:     dropped = disp & 2; break;
1675         case R_SH_DIR10SW: dropped = disp & 1; break;
1676         case R_SH_DIR10SL: dropped = disp & 3; break;
1677         case R_SH_DIR10SQ: dropped = disp & 7; break;
1678         }
1679       if (dropped != 0)
1680         {
1681           (*_bfd_error_handler)
1682             (_("%s: error: unaligned relocation type %d at %08x reloc %08x\n"),
1683              bfd_get_filename (input_bfd), (int)r_type, (unsigned)rel->r_offset, (unsigned)relocation);
1684           bfd_set_error (bfd_error_bad_value);
1685           return FALSE;
1686         }
1687       switch ((int)r_type)
1688         {
1689         case R_SH_64:
1690         case R_SH_64_PCREL:
1691           if (bfd_link_pic (info)
1692               && (input_section->flags & SEC_ALLOC) != 0
1693               && (r_type != R_SH_64_PCREL
1694                   || (h != NULL
1695                       && h->dynindx != -1
1696                       && (! info->symbolic
1697                           || !h->def_regular))))
1698             {
1699               Elf_Internal_Rela outrel;
1700               bfd_byte *loc;
1701               bfd_boolean skip, relocate;
1702
1703               /* When generating a shared object, these relocations
1704                  are copied into the output file to be resolved at run
1705                  time.  */
1706
1707               if (sreloc == NULL)
1708                 {
1709                   sreloc = _bfd_elf_get_dynamic_reloc_section
1710                     (input_bfd, input_section, /*rela?*/ TRUE);
1711                   if (sreloc == NULL)
1712                     return FALSE;
1713                 }
1714
1715               skip = FALSE;
1716               relocate = FALSE;
1717
1718               outrel.r_offset
1719                 = _bfd_elf_section_offset (output_bfd, info,
1720                                            input_section, rel->r_offset);
1721
1722               if (outrel.r_offset == (bfd_vma) -1)
1723                 skip = TRUE;
1724               else if (outrel.r_offset == (bfd_vma) -2)
1725                 skip = TRUE, relocate = TRUE;
1726
1727               outrel.r_offset += (input_section->output_section->vma
1728                                   + input_section->output_offset);
1729
1730               if (skip)
1731                 memset (&outrel, 0, sizeof outrel);
1732               else if (r_type == R_SH_64_PCREL)
1733                 {
1734                   BFD_ASSERT (h != NULL && h->dynindx != -1);
1735                   outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64_PCREL);
1736                   outrel.r_addend = rel->r_addend;
1737                 }
1738               else
1739                 {
1740                   /* h->dynindx may be -1 if this symbol was marked to
1741                      become local.  */
1742                   if (h == NULL
1743                       || ((info->symbolic || h->dynindx == -1)
1744                           && h->def_regular))
1745                     {
1746                       relocate = TRUE;
1747                       outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1748                       outrel.r_addend = relocation + rel->r_addend;
1749                     }
1750                   else
1751                     {
1752                       BFD_ASSERT (h->dynindx != -1);
1753                       outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64);
1754                       outrel.r_addend = relocation + rel->r_addend;
1755                     }
1756                 }
1757
1758               loc = sreloc->contents;
1759               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
1760               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1761
1762               /* If this reloc is against an external symbol, we do
1763                  not want to fiddle with the addend.  Otherwise, we
1764                  need to include the symbol value so that it becomes
1765                  an addend for the dynamic reloc.  */
1766               if (! relocate)
1767                 continue;
1768             }
1769           else if (r_type == R_SH_64)
1770             addend = rel->r_addend;
1771           goto final_link_relocate;
1772
1773         case R_SH_GOTPLT_LOW16:
1774         case R_SH_GOTPLT_MEDLOW16:
1775         case R_SH_GOTPLT_MEDHI16:
1776         case R_SH_GOTPLT_HI16:
1777         case R_SH_GOTPLT10BY4:
1778         case R_SH_GOTPLT10BY8:
1779           /* Relocation is to the entry for this symbol in the
1780              procedure linkage table.  */
1781
1782           if (h == NULL
1783               || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1784               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
1785               || ! bfd_link_pic (info)
1786               || info->symbolic
1787               || h->dynindx == -1
1788               || h->plt.offset == (bfd_vma) -1
1789               || h->got.offset != (bfd_vma) -1)
1790             goto force_got;
1791
1792           /* Relocation is to the entry for this symbol in the global
1793              offset table extension for the procedure linkage table.  */
1794           if (sgotplt == NULL)
1795             {
1796               sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
1797               BFD_ASSERT (sgotplt != NULL);
1798             }
1799
1800           relocation = (sgotplt->output_offset
1801                         + ((h->plt.offset / elf_sh64_sizeof_plt (info)
1802                             - 1 + 3) * 8));
1803
1804           relocation -= GOT_BIAS;
1805
1806           goto final_link_relocate;
1807
1808         force_got:
1809         case R_SH_GOT_LOW16:
1810         case R_SH_GOT_MEDLOW16:
1811         case R_SH_GOT_MEDHI16:
1812         case R_SH_GOT_HI16:
1813         case R_SH_GOT10BY4:
1814         case R_SH_GOT10BY8:
1815           /* Relocation is to the entry for this symbol in the global
1816              offset table.  */
1817           if (sgot == NULL)
1818             {
1819               sgot = bfd_get_linker_section (dynobj, ".got");
1820               BFD_ASSERT (sgot != NULL);
1821             }
1822
1823           if (h != NULL)
1824             {
1825               bfd_vma off;
1826
1827               off = h->got.offset;
1828               if (seen_stt_datalabel)
1829                 {
1830                   struct elf_sh64_link_hash_entry *hsh;
1831
1832                   hsh = (struct elf_sh64_link_hash_entry *)h;
1833                   off = hsh->datalabel_got_offset;
1834                 }
1835               BFD_ASSERT (off != (bfd_vma) -1);
1836
1837               if (! elf_hash_table (info)->dynamic_sections_created
1838                   || (bfd_link_pic (info)
1839                       && (info->symbolic || h->dynindx == -1
1840                           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1841                           || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1842                       && h->def_regular))
1843                 {
1844                   /* This is actually a static link, or it is a
1845                      -Bsymbolic link and the symbol is defined
1846                      locally, or the symbol was forced to be local
1847                      because of a version file.  We must initialize
1848                      this entry in the global offset table.  Since the
1849                      offset must always be a multiple of 4, we use the
1850                      least significant bit to record whether we have
1851                      initialized it already.
1852
1853                      When doing a dynamic link, we create a .rela.got
1854                      relocation entry to initialize the value.  This
1855                      is done in the finish_dynamic_symbol routine.  */
1856                   if ((off & 1) != 0)
1857                     off &= ~1;
1858                   else
1859                     {
1860                       bfd_put_64 (output_bfd, relocation,
1861                                   sgot->contents + off);
1862                       if (seen_stt_datalabel)
1863                         {
1864                           struct elf_sh64_link_hash_entry *hsh;
1865
1866                           hsh = (struct elf_sh64_link_hash_entry *)h;
1867                           hsh->datalabel_got_offset |= 1;
1868                         }
1869                       else
1870                         h->got.offset |= 1;
1871                     }
1872                 }
1873
1874               relocation = sgot->output_offset + off;
1875             }
1876           else
1877             {
1878               bfd_vma off;
1879
1880               if (rel->r_addend)
1881                 {
1882                   BFD_ASSERT (local_got_offsets != NULL
1883                               && (local_got_offsets[symtab_hdr->sh_info
1884                                                     + r_symndx]
1885                                   != (bfd_vma) -1));
1886
1887                   off = local_got_offsets[symtab_hdr->sh_info
1888                                           + r_symndx];
1889                 }
1890               else
1891                 {
1892                   BFD_ASSERT (local_got_offsets != NULL
1893                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
1894
1895                   off = local_got_offsets[r_symndx];
1896                 }
1897
1898               /* The offset must always be a multiple of 8.  We use
1899                  the least significant bit to record whether we have
1900                  already generated the necessary reloc.  */
1901               if ((off & 1) != 0)
1902                 off &= ~1;
1903               else
1904                 {
1905                   bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1906
1907                   if (bfd_link_pic (info))
1908                     {
1909                       asection *s;
1910                       Elf_Internal_Rela outrel;
1911                       bfd_byte *loc;
1912
1913                       s = bfd_get_linker_section (dynobj, ".rela.got");
1914                       BFD_ASSERT (s != NULL);
1915
1916                       outrel.r_offset = (sgot->output_section->vma
1917                                          + sgot->output_offset
1918                                          + off);
1919                       outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1920                       outrel.r_addend = relocation;
1921                       loc = s->contents;
1922                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
1923                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1924                     }
1925
1926                   if (rel->r_addend)
1927                     local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
1928                   else
1929                     local_got_offsets[r_symndx] |= 1;
1930                 }
1931
1932               relocation = sgot->output_offset + off;
1933             }
1934
1935           relocation -= GOT_BIAS;
1936
1937           goto final_link_relocate;
1938
1939         case R_SH_GOTOFF_LOW16:
1940         case R_SH_GOTOFF_MEDLOW16:
1941         case R_SH_GOTOFF_MEDHI16:
1942         case R_SH_GOTOFF_HI16:
1943           /* Relocation is relative to the start of the global offset
1944              table.  */
1945
1946           if (sgot == NULL)
1947             {
1948               sgot = bfd_get_linker_section (dynobj, ".got");
1949               BFD_ASSERT (sgot != NULL);
1950             }
1951
1952           /* Note that sgot->output_offset is not involved in this
1953              calculation.  We always want the start of .got.  If we
1954              defined _GLOBAL_OFFSET_TABLE in a different way, as is
1955              permitted by the ABI, we might have to change this
1956              calculation.  */
1957           relocation -= sgot->output_section->vma;
1958
1959           relocation -= GOT_BIAS;
1960
1961           addend = rel->r_addend;
1962
1963           goto final_link_relocate;
1964
1965         case R_SH_GOTPC_LOW16:
1966         case R_SH_GOTPC_MEDLOW16:
1967         case R_SH_GOTPC_MEDHI16:
1968         case R_SH_GOTPC_HI16:
1969           /* Use global offset table as symbol value.  */
1970
1971           if (sgot == NULL)
1972             {
1973               sgot = bfd_get_linker_section (dynobj, ".got");
1974               BFD_ASSERT (sgot != NULL);
1975             }
1976
1977           relocation = sgot->output_section->vma;
1978
1979           relocation += GOT_BIAS;
1980
1981           addend = rel->r_addend;
1982
1983           goto final_link_relocate;
1984
1985         case R_SH_PLT_LOW16:
1986         case R_SH_PLT_MEDLOW16:
1987         case R_SH_PLT_MEDHI16:
1988         case R_SH_PLT_HI16:
1989           /* Relocation is to the entry for this symbol in the
1990              procedure linkage table.  */
1991
1992           /* Resolve a PLT reloc against a local symbol directly,
1993              without using the procedure linkage table.  */
1994           if (h == NULL)
1995             goto final_link_relocate;
1996
1997           if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1998               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1999             goto final_link_relocate;
2000
2001           if (h->plt.offset == (bfd_vma) -1)
2002             {
2003               /* We didn't make a PLT entry for this symbol.  This
2004                  happens when statically linking PIC code, or when
2005                  using -Bsymbolic.  */
2006               goto final_link_relocate;
2007             }
2008
2009           if (splt == NULL)
2010             {
2011               splt = bfd_get_linker_section (dynobj, ".plt");
2012               BFD_ASSERT (splt != NULL);
2013             }
2014
2015           relocation = (splt->output_section->vma
2016                         + splt->output_offset
2017                         + h->plt.offset);
2018           relocation++;
2019
2020           addend = rel->r_addend;
2021
2022           goto final_link_relocate;
2023
2024         case R_SH_DIR32:
2025         case R_SH_SHMEDIA_CODE:
2026         case R_SH_PT_16:
2027         case R_SH_DIR5U:
2028         case R_SH_DIR6S:
2029         case R_SH_DIR6U:
2030         case R_SH_DIR10S:
2031         case R_SH_DIR10SW:
2032         case R_SH_DIR10SL:
2033         case R_SH_DIR10SQ:
2034         case R_SH_IMMS16:
2035         case R_SH_IMMU16:
2036         case R_SH_IMM_LOW16:
2037         case R_SH_IMM_LOW16_PCREL:
2038         case R_SH_IMM_MEDLOW16:
2039         case R_SH_IMM_MEDLOW16_PCREL:
2040         case R_SH_IMM_MEDHI16:
2041         case R_SH_IMM_MEDHI16_PCREL:
2042         case R_SH_IMM_HI16:
2043         case R_SH_IMM_HI16_PCREL:
2044           addend = rel->r_addend;
2045           /* Fall through.  */
2046         case R_SH_REL32:
2047         final_link_relocate:
2048           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2049                                         contents, rel->r_offset,
2050                                         relocation, addend);
2051           break;
2052
2053         default:
2054           bfd_set_error (bfd_error_bad_value);
2055           return FALSE;
2056
2057         }
2058
2059       if (r != bfd_reloc_ok)
2060         {
2061           switch (r)
2062             {
2063             default:
2064             case bfd_reloc_outofrange:
2065               abort ();
2066             case bfd_reloc_overflow:
2067               {
2068                 const char *name;
2069
2070                 if (h != NULL)
2071                   name = NULL;
2072                 else
2073                   {
2074                     name = (bfd_elf_string_from_elf_section
2075                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
2076                     if (name == NULL)
2077                       return FALSE;
2078                     if (*name == '\0')
2079                       name = bfd_section_name (input_bfd, sec);
2080                   }
2081                 (*info->callbacks->reloc_overflow)
2082                   (info, (h ? &h->root : NULL), name, howto->name,
2083                    (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2084               }
2085               break;
2086             }
2087         }
2088     }
2089
2090   return TRUE;
2091 }
2092
2093 /* This is a version of bfd_generic_get_relocated_section_contents
2094    that uses sh_elf64_relocate_section.
2095
2096    See sh_elf_relocate_section in elf32-sh.c for the original.  */
2097
2098 static bfd_byte *
2099 sh_elf64_get_relocated_section_contents (bfd *output_bfd,
2100                                          struct bfd_link_info *link_info,
2101                                          struct bfd_link_order *link_order,
2102                                          bfd_byte *data,
2103                                          bfd_boolean relocatable,
2104                                          asymbol **symbols)
2105 {
2106   Elf_Internal_Shdr *symtab_hdr;
2107   asection *input_section = link_order->u.indirect.section;
2108   bfd *input_bfd = input_section->owner;
2109   asection **sections = NULL;
2110   Elf_Internal_Rela *internal_relocs = NULL;
2111   Elf_Internal_Sym *isymbuf = NULL;
2112
2113   /* We only need to handle the case of relaxing, or of having a
2114      particular set of section contents, specially.  */
2115   if (relocatable
2116       || elf_section_data (input_section)->this_hdr.contents == NULL)
2117     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2118                                                        link_order, data,
2119                                                        relocatable,
2120                                                        symbols);
2121
2122   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2123
2124   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2125           input_section->size);
2126
2127   if ((input_section->flags & SEC_RELOC) != 0
2128       && input_section->reloc_count > 0)
2129     {
2130       Elf_Internal_Sym *isymp;
2131       Elf_Internal_Sym *isymend;
2132       asection **secpp;
2133
2134       /* Read this BFD's local symbols.  */
2135       if (symtab_hdr->sh_info != 0)
2136         {
2137           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2138           if (isymbuf == NULL)
2139             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2140                                             symtab_hdr->sh_info, 0,
2141                                             NULL, NULL, NULL);
2142           if (isymbuf == NULL)
2143             goto error_return;
2144         }
2145
2146       internal_relocs = (_bfd_elf_link_read_relocs
2147                          (input_bfd, input_section, NULL,
2148                           (Elf_Internal_Rela *) NULL, FALSE));
2149       if (internal_relocs == NULL)
2150         goto error_return;
2151
2152       sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2153                                            * sizeof (asection *));
2154       if (sections == NULL && symtab_hdr->sh_info > 0)
2155         goto error_return;
2156
2157       secpp = sections;
2158       isymend = isymbuf + symtab_hdr->sh_info;
2159       for (isymp = isymbuf; isymp < isymend; ++isymp, ++secpp)
2160         {
2161           asection *isec;
2162
2163           if (isymp->st_shndx == SHN_UNDEF)
2164             isec = bfd_und_section_ptr;
2165           else if (isymp->st_shndx == SHN_ABS)
2166             isec = bfd_abs_section_ptr;
2167           else if (isymp->st_shndx == SHN_COMMON)
2168             isec = bfd_com_section_ptr;
2169           else
2170             isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2171
2172           *secpp = isec;
2173         }
2174
2175       if (! sh_elf64_relocate_section (output_bfd, link_info, input_bfd,
2176                                        input_section, data, internal_relocs,
2177                                        isymbuf, sections))
2178         goto error_return;
2179
2180       if (sections != NULL)
2181         free (sections);
2182       if (internal_relocs != elf_section_data (input_section)->relocs)
2183         free (internal_relocs);
2184       if (isymbuf != NULL
2185           && (unsigned char *) isymbuf != symtab_hdr->contents)
2186         free (isymbuf);
2187     }
2188
2189   return data;
2190
2191  error_return:
2192   if (sections != NULL)
2193     free (sections);
2194   if (internal_relocs != NULL
2195       && internal_relocs != elf_section_data (input_section)->relocs)
2196     free (internal_relocs);
2197   if (isymbuf != NULL
2198       && (unsigned char *) isymbuf != symtab_hdr->contents)
2199     free (isymbuf);
2200   return NULL;
2201 }
2202
2203 /* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections.  */
2204
2205 static bfd_boolean
2206 sh64_elf64_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2207                           Elf_Internal_Shdr *elf_section_hdr,
2208                           asection *asect)
2209 {
2210   /* Code sections can only contain SH64 code, so mark them as such.  */
2211   if (bfd_get_section_flags (output_bfd, asect) & SEC_CODE)
2212     elf_section_hdr->sh_flags |= SHF_SH5_ISA32;
2213
2214   return TRUE;
2215 }
2216
2217 static bfd_boolean
2218 sh_elf64_set_mach_from_flags (bfd *abfd)
2219 {
2220   flagword flags = elf_elfheader (abfd)->e_flags;
2221
2222   switch (flags & EF_SH_MACH_MASK)
2223     {
2224     case EF_SH5:
2225       /* Just one, but keep the switch construct to make additions easy.  */
2226       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
2227       break;
2228
2229     default:
2230       bfd_set_error (bfd_error_wrong_format);
2231       return FALSE;
2232     }
2233   return TRUE;
2234 }
2235
2236 /* Function to keep SH64 specific file flags.
2237
2238    See sh64_elf_set_private_flags in elf32-sh64.c for the original.  */
2239
2240 static bfd_boolean
2241 sh_elf64_set_private_flags (bfd *abfd, flagword flags)
2242 {
2243   BFD_ASSERT (! elf_flags_init (abfd)
2244               || elf_elfheader (abfd)->e_flags == flags);
2245
2246   elf_elfheader (abfd)->e_flags = flags;
2247   elf_flags_init (abfd) = TRUE;
2248   return sh_elf64_set_mach_from_flags (abfd);
2249 }
2250
2251 /* Copy the SHF_SH5_ISA32 attribute that we keep on all sections with
2252    code, to keep attributes the same as for SHmedia in 32-bit ELF.  */
2253
2254 static bfd_boolean
2255 sh_elf64_copy_private_data_internal (bfd *ibfd, bfd *obfd)
2256 {
2257   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2258       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2259     return TRUE;
2260
2261   /* Copy object attributes.  */
2262   _bfd_elf_copy_private_bfd_data (ibfd, obfd);
2263
2264   return sh_elf64_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
2265 }
2266
2267 static bfd_boolean
2268 sh_elf64_copy_private_data (bfd *ibfd, bfd *obfd)
2269 {
2270   return sh_elf64_copy_private_data_internal (ibfd, obfd);
2271 }
2272
2273 static bfd_boolean
2274 sh_elf64_merge_private_data (bfd *ibfd, bfd *obfd)
2275 {
2276   flagword old_flags, new_flags;
2277
2278   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2279     return FALSE;
2280
2281   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2282       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2283     return TRUE;
2284
2285   if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
2286     {
2287       const char *msg;
2288
2289       if (bfd_get_arch_size (ibfd) == 32
2290           && bfd_get_arch_size (obfd) == 64)
2291         msg = _("%s: compiled as 32-bit object and %s is 64-bit");
2292       else if (bfd_get_arch_size (ibfd) == 64
2293                && bfd_get_arch_size (obfd) == 32)
2294         msg = _("%s: compiled as 64-bit object and %s is 32-bit");
2295       else
2296         msg = _("%s: object size does not match that of target %s");
2297
2298       (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
2299                              bfd_get_filename (obfd));
2300       bfd_set_error (bfd_error_wrong_format);
2301       return FALSE;
2302     }
2303
2304   old_flags = elf_elfheader (obfd)->e_flags;
2305   new_flags = elf_elfheader (ibfd)->e_flags;
2306   if (! elf_flags_init (obfd))
2307     {
2308       /* This happens when ld starts out with a 'blank' output file.  */
2309       elf_flags_init (obfd) = TRUE;
2310       elf_elfheader (obfd)->e_flags = old_flags = new_flags;
2311     }
2312   /* We don't allow linking in anything else than SH64 code, and since
2313      this is a 64-bit ELF, we assume the 64-bit ABI is used.  Add code
2314      here as things change.  */
2315   else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
2316     {
2317       (*_bfd_error_handler)
2318         ("%s: does not use the SH64 64-bit ABI as previous modules do",
2319          bfd_get_filename (ibfd));
2320       bfd_set_error (bfd_error_bad_value);
2321       return FALSE;
2322     }
2323
2324   sh_elf64_copy_private_data_internal (ibfd, obfd);
2325
2326   /* I can't think of anything sane other than old_flags being EF_SH5 and
2327      that we need to preserve that.  */
2328   elf_elfheader (obfd)->e_flags = old_flags;
2329
2330   return sh_elf64_set_mach_from_flags (obfd);
2331 }
2332
2333 /* Return the section that should be marked against GC for a given
2334    relocation.  */
2335
2336 static asection *
2337 sh_elf64_gc_mark_hook (asection *sec,
2338                        struct bfd_link_info *info,
2339                        Elf_Internal_Rela *rel,
2340                        struct elf_link_hash_entry *h,
2341                        Elf_Internal_Sym *sym)
2342 {
2343   if (h != NULL)
2344     switch (ELF64_R_TYPE (rel->r_info))
2345       {
2346       case R_SH_GNU_VTINHERIT:
2347       case R_SH_GNU_VTENTRY:
2348         return NULL;
2349       }
2350
2351   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2352 }
2353
2354 /* Look through the relocs for a section during the first phase.
2355    Since we don't do .gots or .plts, we just need to consider the
2356    virtual table relocs for gc.  */
2357
2358 static bfd_boolean
2359 sh_elf64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2360                        asection *sec, const Elf_Internal_Rela *relocs)
2361 {
2362   Elf_Internal_Shdr *symtab_hdr;
2363   struct elf_link_hash_entry **sym_hashes;
2364   const Elf_Internal_Rela *rel;
2365   const Elf_Internal_Rela *rel_end;
2366   bfd *dynobj;
2367   bfd_vma *local_got_offsets;
2368   asection *sgot;
2369   asection *srelgot;
2370   asection *sreloc;
2371
2372   sgot = NULL;
2373   srelgot = NULL;
2374   sreloc = NULL;
2375
2376   if (bfd_link_relocatable (info))
2377     return TRUE;
2378
2379   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2380   sym_hashes = elf_sym_hashes (abfd);
2381
2382   dynobj = elf_hash_table (info)->dynobj;
2383   local_got_offsets = elf_local_got_offsets (abfd);
2384
2385   rel_end = relocs + sec->reloc_count;
2386   for (rel = relocs; rel < rel_end; rel++)
2387     {
2388       struct elf_link_hash_entry *h;
2389       unsigned long r_symndx;
2390
2391       r_symndx = ELF64_R_SYM (rel->r_info);
2392       if (r_symndx < symtab_hdr->sh_info)
2393         h = NULL;
2394       else
2395         {
2396           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2397           while (h->root.type == bfd_link_hash_indirect
2398                  || h->root.type == bfd_link_hash_warning)
2399             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2400
2401           /* PR15323, ref flags aren't set for references in the same
2402              object.  */
2403           h->root.non_ir_ref = 1;
2404         }
2405
2406       /* Some relocs require a global offset table.  */
2407       if (dynobj == NULL)
2408         {
2409           switch (ELF64_R_TYPE (rel->r_info))
2410             {
2411             case R_SH_GOTPLT_LOW16:
2412             case R_SH_GOTPLT_MEDLOW16:
2413             case R_SH_GOTPLT_MEDHI16:
2414             case R_SH_GOTPLT_HI16:
2415             case R_SH_GOTPLT10BY4:
2416             case R_SH_GOTPLT10BY8:
2417             case R_SH_GOT_LOW16:
2418             case R_SH_GOT_MEDLOW16:
2419             case R_SH_GOT_MEDHI16:
2420             case R_SH_GOT_HI16:
2421             case R_SH_GOT10BY4:
2422             case R_SH_GOT10BY8:
2423             case R_SH_GOTOFF_LOW16:
2424             case R_SH_GOTOFF_MEDLOW16:
2425             case R_SH_GOTOFF_MEDHI16:
2426             case R_SH_GOTOFF_HI16:
2427             case R_SH_GOTPC_LOW16:
2428             case R_SH_GOTPC_MEDLOW16:
2429             case R_SH_GOTPC_MEDHI16:
2430             case R_SH_GOTPC_HI16:
2431               elf_hash_table (info)->dynobj = dynobj = abfd;
2432               if (! _bfd_elf_create_got_section (dynobj, info))
2433                 return FALSE;
2434               break;
2435
2436             default:
2437               break;
2438             }
2439         }
2440
2441       switch (ELF64_R_TYPE (rel->r_info))
2442         {
2443           /* This relocation describes the C++ object vtable hierarchy.
2444              Reconstruct it for later use during GC.  */
2445         case R_SH_GNU_VTINHERIT:
2446           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2447             return FALSE;
2448           break;
2449
2450           /* This relocation describes which C++ vtable entries are actually
2451              used.  Record for later use during GC.  */
2452         case R_SH_GNU_VTENTRY:
2453           BFD_ASSERT (h != NULL);
2454           if (h != NULL
2455               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2456             return FALSE;
2457           break;
2458
2459         force_got:
2460         case R_SH_GOT_LOW16:
2461         case R_SH_GOT_MEDLOW16:
2462         case R_SH_GOT_MEDHI16:
2463         case R_SH_GOT_HI16:
2464         case R_SH_GOT10BY4:
2465         case R_SH_GOT10BY8:
2466           /* This symbol requires a global offset table entry.  */
2467
2468           if (sgot == NULL)
2469             {
2470               sgot = bfd_get_linker_section (dynobj, ".got");
2471               BFD_ASSERT (sgot != NULL);
2472             }
2473
2474           if (srelgot == NULL
2475               && (h != NULL || bfd_link_pic (info)))
2476             {
2477               srelgot = bfd_get_linker_section (dynobj, ".rela.got");
2478               if (srelgot == NULL)
2479                 {
2480                   flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2481                                     | SEC_IN_MEMORY | SEC_LINKER_CREATED
2482                                     | SEC_READONLY);
2483                   srelgot = bfd_make_section_anyway_with_flags (dynobj,
2484                                                                 ".rela.got",
2485                                                                 flags);
2486                   if (srelgot == NULL
2487                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2488                     return FALSE;
2489                 }
2490             }
2491
2492           if (h != NULL)
2493             {
2494               if (h->type == STT_DATALABEL)
2495                 {
2496                   struct elf_sh64_link_hash_entry *hsh;
2497
2498                   h = (struct elf_link_hash_entry *) h->root.u.i.link;
2499                   hsh = (struct elf_sh64_link_hash_entry *)h;
2500                   if (hsh->datalabel_got_offset != (bfd_vma) -1)
2501                     break;
2502
2503                   hsh->datalabel_got_offset = sgot->size;
2504                 }
2505               else
2506                 {
2507                   if (h->got.offset != (bfd_vma) -1)
2508                     {
2509                       /* We have already allocated space in the .got.  */
2510                       break;
2511                     }
2512                   h->got.offset = sgot->size;
2513                 }
2514
2515               /* Make sure this symbol is output as a dynamic symbol.  */
2516               if (h->dynindx == -1)
2517                 {
2518                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
2519                     return FALSE;
2520                 }
2521
2522               srelgot->size += sizeof (Elf64_External_Rela);
2523             }
2524           else
2525             {
2526               /* This is a global offset table entry for a local
2527                  symbol.  */
2528               if (local_got_offsets == NULL)
2529                 {
2530                   size_t size;
2531                   register unsigned int i;
2532
2533                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
2534                   /* Reserve space for both the datalabel and
2535                      codelabel local GOT offsets.  */
2536                   size *= 2;
2537                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2538                   if (local_got_offsets == NULL)
2539                     return FALSE;
2540                   elf_local_got_offsets (abfd) = local_got_offsets;
2541                   for (i = 0; i < symtab_hdr->sh_info; i++)
2542                     local_got_offsets[i] = (bfd_vma) -1;
2543                   for (; i < 2 * symtab_hdr->sh_info; i++)
2544                     local_got_offsets[i] = (bfd_vma) -1;
2545                 }
2546               if ((rel->r_addend & 1) != 0)
2547                 {
2548                   if (local_got_offsets[symtab_hdr->sh_info
2549                                         + r_symndx] != (bfd_vma) -1)
2550                     {
2551                       /* We have already allocated space in the .got.  */
2552                       break;
2553                     }
2554                   local_got_offsets[symtab_hdr->sh_info
2555                                     + r_symndx] = sgot->size;
2556                 }
2557               else
2558                 {
2559                   if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2560                     {
2561                       /* We have already allocated space in the .got.  */
2562                       break;
2563                     }
2564                   local_got_offsets[r_symndx] = sgot->size;
2565                 }
2566
2567               if (bfd_link_pic (info))
2568                 {
2569                   /* If we are generating a shared object, we need to
2570                      output a R_SH_RELATIVE reloc so that the dynamic
2571                      linker can adjust this GOT entry.  */
2572                   srelgot->size += sizeof (Elf64_External_Rela);
2573                 }
2574             }
2575
2576           sgot->size += 8;
2577
2578           break;
2579
2580         case R_SH_GOTPLT_LOW16:
2581         case R_SH_GOTPLT_MEDLOW16:
2582         case R_SH_GOTPLT_MEDHI16:
2583         case R_SH_GOTPLT_HI16:
2584         case R_SH_GOTPLT10BY4:
2585         case R_SH_GOTPLT10BY8:
2586           /* If this is a local symbol, we resolve it directly without
2587              creating a procedure linkage table entry.  */
2588
2589           if (h == NULL
2590               || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2591               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2592               || ! bfd_link_pic (info)
2593               || info->symbolic
2594               || h->dynindx == -1
2595               || h->got.offset != (bfd_vma) -1)
2596             goto force_got;
2597
2598           /* Make sure this symbol is output as a dynamic symbol.  */
2599           if (h->dynindx == -1)
2600             {
2601               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2602                 return FALSE;
2603             }
2604
2605           h->needs_plt = 1;
2606
2607           break;
2608
2609         case R_SH_PLT_LOW16:
2610         case R_SH_PLT_MEDLOW16:
2611         case R_SH_PLT_MEDHI16:
2612         case R_SH_PLT_HI16:
2613           /* This symbol requires a procedure linkage table entry.  We
2614              actually build the entry in adjust_dynamic_symbol,
2615              because this might be a case of linking PIC code which is
2616              never referenced by a dynamic object, in which case we
2617              don't need to generate a procedure linkage table entry
2618              after all.  */
2619
2620           /* If this is a local symbol, we resolve it directly without
2621              creating a procedure linkage table entry.  */
2622           if (h == NULL)
2623             continue;
2624
2625           if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2626               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
2627             break;
2628
2629           h->needs_plt = 1;
2630
2631           break;
2632
2633         case R_SH_64:
2634         case R_SH_64_PCREL:
2635           if (h != NULL)
2636             h->non_got_ref = 1;
2637
2638           /* If we are creating a shared library, and this is a reloc
2639              against a global symbol, or a non PC relative reloc
2640              against a local symbol, then we need to copy the reloc
2641              into the shared library.  However, if we are linking with
2642              -Bsymbolic, we do not need to copy a reloc against a
2643              global symbol which is defined in an object we are
2644              including in the link (i.e., DEF_REGULAR is set).  At
2645              this point we have not seen all the input files, so it is
2646              possible that DEF_REGULAR is not set now but will be set
2647              later (it is never cleared).  We account for that
2648              possibility below by storing information in the
2649              pcrel_relocs_copied field of the hash table entry.  */
2650           if (bfd_link_pic (info)
2651               && (sec->flags & SEC_ALLOC) != 0
2652               && (ELF32_R_TYPE (rel->r_info) != R_SH_64_PCREL
2653                   || (h != NULL
2654                       && (! info->symbolic
2655                           || !h->def_regular))))
2656             {
2657               /* When creating a shared object, we must copy these
2658                  reloc types into the output file.  We create a reloc
2659                  section in dynobj and make room for this reloc.  */
2660               if (sreloc == NULL)
2661                 {
2662                   sreloc = _bfd_elf_make_dynamic_reloc_section
2663                     (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2664
2665                   if (sreloc == NULL)
2666                     return FALSE;
2667                 }
2668
2669               sreloc->size += sizeof (Elf64_External_Rela);
2670
2671               /* If we are linking with -Bsymbolic, and this is a
2672                  global symbol, we count the number of PC relative
2673                  relocations we have entered for this symbol, so that
2674                  we can discard them again if the symbol is later
2675                  defined by a regular object.  Note that this function
2676                  is only called if we are using an elf_sh linker
2677                  hash table, which means that h is really a pointer to
2678                  an elf_sh_link_hash_entry.  */
2679               if (h != NULL && info->symbolic
2680                   && ELF64_R_TYPE (rel->r_info) == R_SH_64_PCREL)
2681                 {
2682                   struct elf_sh64_link_hash_entry *eh;
2683                   struct elf_sh64_pcrel_relocs_copied *p;
2684
2685                   eh = (struct elf_sh64_link_hash_entry *) h;
2686
2687                   for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2688                     if (p->section == sreloc)
2689                       break;
2690
2691                   if (p == NULL)
2692                     {
2693                       p = ((struct elf_sh64_pcrel_relocs_copied *)
2694                            bfd_alloc (dynobj, sizeof *p));
2695                       if (p == NULL)
2696                         return FALSE;
2697                       p->next = eh->pcrel_relocs_copied;
2698                       eh->pcrel_relocs_copied = p;
2699                       p->section = sreloc;
2700                       p->count = 0;
2701                     }
2702
2703                   ++p->count;
2704                 }
2705             }
2706
2707           break;
2708         }
2709     }
2710
2711   return TRUE;
2712 }
2713
2714 static int
2715 sh64_elf64_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
2716 {
2717   if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
2718     return STT_DATALABEL;
2719
2720   return type;
2721 }
2722
2723 /* FIXME: This is a copy of sh64_elf_add_symbol_hook in elf32-sh64.c.
2724    Either file can presumably exist without the other, but do not differ
2725    in elf-size-ness.  How to share?
2726
2727    Hook called by the linker routine which adds symbols from an object
2728    file.  We must make indirect symbols for undefined symbols marked with
2729    STT_DATALABEL, so relocations passing them will pick up that attribute
2730    and neutralize STO_SH5_ISA32 found on the symbol definition.
2731
2732    There is a problem, though: We want to fill in the hash-table entry for
2733    this symbol and signal to the caller that no further processing is
2734    needed.  But we don't have the index for this hash-table entry.  We
2735    rely here on that the current entry is the first hash-entry with NULL,
2736    which seems brittle.  Also, iterating over the hash-table to find that
2737    entry is a linear operation on the number of symbols in this input
2738    file, and this function should take constant time, so that's not good
2739    too.  Only comfort is that DataLabel references should only be found in
2740    hand-written assembly code and thus be rare.  FIXME: Talk maintainers
2741    into adding an option to elf_add_symbol_hook (preferably) for the index
2742    or the hash entry, alternatively adding the index to Elf_Internal_Sym
2743    (not so good).  */
2744
2745 static bfd_boolean
2746 sh64_elf64_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
2747                             Elf_Internal_Sym *sym, const char **namep,
2748                             flagword *flagsp ATTRIBUTE_UNUSED,
2749                             asection **secp, bfd_vma *valp)
2750 {
2751   /* We want to do this for relocatable as well as final linking.  */
2752   if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
2753       && is_elf_hash_table (info->hash))
2754     {
2755       struct elf_link_hash_entry *h;
2756
2757       /* For relocatable links, we register the DataLabel sym in its own
2758          right, and tweak the name when it's output.  Otherwise, we make
2759          an indirect symbol of it.  */
2760       flagword flags
2761         = bfd_link_relocatable (info) || info->emitrelocations
2762         ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
2763
2764       char *dl_name
2765         = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
2766       struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
2767
2768       BFD_ASSERT (sym_hash != NULL);
2769
2770       /* Allocation may fail.  */
2771       if (dl_name == NULL)
2772         return FALSE;
2773
2774       strcpy (dl_name, *namep);
2775       strcat (dl_name, DATALABEL_SUFFIX);
2776
2777       h = (struct elf_link_hash_entry *)
2778         bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
2779
2780       if (h == NULL)
2781         {
2782           /* No previous datalabel symbol.  Make one.  */
2783           struct bfd_link_hash_entry *bh = NULL;
2784           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2785
2786           if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
2787                                                   flags, *secp, *valp,
2788                                                   *namep, FALSE,
2789                                                   bed->collect, &bh))
2790             {
2791               free (dl_name);
2792               return FALSE;
2793             }
2794
2795           h = (struct elf_link_hash_entry *) bh;
2796           h->non_elf = 0;
2797           h->type = STT_DATALABEL;
2798         }
2799       else
2800         /* If a new symbol was created, it holds the allocated name.
2801            Otherwise, we don't need it anymore and should deallocate it.  */
2802         free (dl_name);
2803
2804       if (h->type != STT_DATALABEL
2805           || ((bfd_link_relocatable (info) || info->emitrelocations)
2806               && h->root.type != bfd_link_hash_undefined)
2807           || (! bfd_link_relocatable (info) && !info->emitrelocations
2808               && h->root.type != bfd_link_hash_indirect))
2809         {
2810           /* Make sure we don't get confused on invalid input.  */
2811           (*_bfd_error_handler)
2812             (_("%s: encountered datalabel symbol in input"),
2813              bfd_get_filename (abfd));
2814           bfd_set_error (bfd_error_bad_value);
2815           return FALSE;
2816         }
2817
2818       /* Now find the hash-table slot for this entry and fill it in.  */
2819       while (*sym_hash != NULL)
2820         sym_hash++;
2821       *sym_hash = h;
2822
2823       /* Signal to caller to skip this symbol - we've handled it.  */
2824       *namep = NULL;
2825     }
2826
2827   return TRUE;
2828 }
2829
2830 /* This hook function is called before the linker writes out a global
2831    symbol.  For relocatable links, DataLabel symbols will be present in
2832    linker output.  We cut off the special suffix on those symbols, so the
2833    right name appears in the output.
2834
2835    When linking and emitting relocations, there can appear global symbols
2836    that are not referenced by relocs, but rather only implicitly through
2837    DataLabel references, a relation that is not visible to the linker.
2838    Since no stripping of global symbols in done when doing such linking,
2839    we don't need to look up and make sure to emit the main symbol for each
2840    DataLabel symbol.  */
2841
2842 static int
2843 sh64_elf64_link_output_symbol_hook (struct bfd_link_info *info,
2844                                     const char *cname,
2845                                     Elf_Internal_Sym *sym,
2846                                     asection *input_sec ATTRIBUTE_UNUSED,
2847                                     struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
2848 {
2849   char *name = (char *) cname;
2850
2851   if (bfd_link_relocatable (info) || info->emitrelocations)
2852     {
2853       if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
2854         name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
2855     }
2856
2857   return 1;
2858 }
2859
2860 /* Set bit 0 on the entry address; it always points to SHmedia code.  This
2861    is mostly for symmetry with the 32-bit format, where code can be
2862    SHcompact and we need to make a distinction to make sure execution
2863    starts in the right ISA mode.  It is also convenient for a loader,
2864    which would otherwise have to set this bit when loading a TR register
2865    before jumping to the program entry.  */
2866
2867 static void
2868 sh64_elf64_final_write_processing (bfd *abfd,
2869                                    bfd_boolean linker ATTRIBUTE_UNUSED)
2870 {
2871   /* FIXME: Perhaps we shouldn't do this if the entry address was supplied
2872      numerically, but we currently lack the infrastructure to recognize
2873      that: The entry symbol, and info whether it is numeric or a symbol
2874      name is kept private in the linker.  */
2875   if (elf_elfheader (abfd)->e_type == ET_EXEC)
2876     elf_elfheader (abfd)->e_entry |= 1;
2877 }
2878
2879 /* First entry in an absolute procedure linkage table look like this.  */
2880
2881 static const bfd_byte elf_sh64_plt0_entry_be[PLT_ENTRY_SIZE] =
2882 {
2883   0xcc, 0x00, 0x01, 0x10, /* movi  .got.plt >> 48, r17 */
2884   0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 32) & 65535, r17 */
2885   0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 16) & 65535, r17 */
2886   0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
2887   0x8d, 0x10, 0x09, 0x90, /* ld.q  r17, 16, r25 */
2888   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2889   0x8d, 0x10, 0x05, 0x10, /* ld.q  r17, 8, r17 */
2890   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2891   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2892   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2893   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2894   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2895   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2896   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2897   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2898   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2899 };
2900
2901 static const bfd_byte elf_sh64_plt0_entry_le[PLT_ENTRY_SIZE] =
2902 {
2903   0x10, 0x01, 0x00, 0xcc, /* movi  .got.plt >> 16, r17 */
2904   0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 32) & 65535, r17 */
2905   0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 16) & 65535, r17 */
2906   0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
2907   0x90, 0x09, 0x10, 0x8d, /* ld.q  r17, 16, r25 */
2908   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2909   0x10, 0x05, 0x10, 0x8d, /* ld.q  r17, 8, r17 */
2910   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2911   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2912   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2913   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2914   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2915   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2916   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2917   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2918   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2919 };
2920
2921 /* Sebsequent entries in an absolute procedure linkage table look like
2922    this.  */
2923
2924 static const bfd_byte elf_sh64_plt_entry_be[PLT_ENTRY_SIZE] =
2925 {
2926   0xcc, 0x00, 0x01, 0x90, /* movi  nameN-in-GOT >> 48, r25 */
2927   0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 32) & 65535, r25 */
2928   0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 16) & 65535, r25 */
2929   0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
2930   0x8d, 0x90, 0x01, 0x90, /* ld.q  r25, 0, r25 */
2931   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2932   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2933   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2934   0xcc, 0x00, 0x01, 0x90, /* movi  (.+8-.PLT0) >> 16, r25 */
2935   0xc8, 0x00, 0x01, 0x90, /* shori (.+4-.PLT0) & 65535, r25 */
2936   0x6b, 0xf5, 0x66, 0x00, /* ptrel r25, tr0 */
2937   0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
2938   0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
2939   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2940   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2941   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2942 };
2943
2944 static const bfd_byte elf_sh64_plt_entry_le[PLT_ENTRY_SIZE] =
2945 {
2946   0x90, 0x01, 0x00, 0xcc, /* movi  nameN-in-GOT >> 16, r25 */
2947   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2948   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2949   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2950   0x90, 0x01, 0x90, 0x8d, /* ld.q  r25, 0, r25 */
2951   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2952   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2953   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2954   0x90, 0x01, 0x00, 0xcc, /* movi  (.+8-.PLT0) >> 16, r25 */
2955   0x90, 0x01, 0x00, 0xc8, /* shori (.+4-.PLT0) & 65535, r25 */
2956   0x00, 0x66, 0xf5, 0x6b, /* ptrel r25, tr0 */
2957   0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
2958   0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
2959   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2960   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2961   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2962 };
2963
2964 /* Entries in a PIC procedure linkage table look like this.  */
2965
2966 static const bfd_byte elf_sh64_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2967 {
2968   0xcc, 0x00, 0x01, 0x90, /* movi  nameN@GOT >> 16, r25 */
2969   0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
2970   0x40, 0xc3, 0x65, 0x90, /* ldx.q r12, r25, r25 */
2971   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2972   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2973   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2974   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2975   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2976   0xce, 0x00, 0x01, 0x10, /* movi  -GOT_BIAS, r17 */
2977   0x00, 0xc9, 0x45, 0x10, /* add   r12, r17, r17 */
2978   0x8d, 0x10, 0x09, 0x90, /* ld.q  r17, 16, r25 */
2979   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2980   0x8d, 0x10, 0x05, 0x10, /* ld.q  r17, 8, r17 */
2981   0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
2982   0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
2983   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2984 };
2985
2986 static const bfd_byte elf_sh64_pic_plt_entry_le[PLT_ENTRY_SIZE] =
2987 {
2988   0x90, 0x01, 0x00, 0xcc, /* movi  nameN@GOT >> 16, r25 */
2989   0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
2990   0x90, 0x65, 0xc3, 0x40, /* ldx.q r12, r25, r25 */
2991   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2992   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2993   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2994   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2995   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2996   0x10, 0x01, 0x00, 0xce, /* movi  -GOT_BIAS, r17 */
2997   0x10, 0x45, 0xc9, 0x00, /* add   r12, r17, r17 */
2998   0x90, 0x09, 0x10, 0x8d, /* ld.q  r17, 16, r25 */
2999   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3000   0x10, 0x05, 0x10, 0x8d, /* ld.q  r17, 8, r17 */
3001   0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
3002   0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3003   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3004 };
3005
3006 static const bfd_byte *elf_sh64_plt0_entry;
3007 static const bfd_byte *elf_sh64_plt_entry;
3008 static const bfd_byte *elf_sh64_pic_plt_entry;
3009
3010 /* Create an entry in an sh ELF linker hash table.  */
3011
3012 static struct bfd_hash_entry *
3013 sh64_elf64_link_hash_newfunc (struct bfd_hash_entry *entry,
3014                               struct bfd_hash_table *table,
3015                               const char *string)
3016 {
3017   struct elf_sh64_link_hash_entry *ret =
3018     (struct elf_sh64_link_hash_entry *) entry;
3019
3020   /* Allocate the structure if it has not already been allocated by a
3021      subclass.  */
3022   if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3023     ret = ((struct elf_sh64_link_hash_entry *)
3024            bfd_hash_allocate (table,
3025                               sizeof (struct elf_sh64_link_hash_entry)));
3026   if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3027     return (struct bfd_hash_entry *) ret;
3028
3029   /* Call the allocation method of the superclass.  */
3030   ret = ((struct elf_sh64_link_hash_entry *)
3031          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3032                                      table, string));
3033   if (ret != (struct elf_sh64_link_hash_entry *) NULL)
3034     {
3035       ret->pcrel_relocs_copied = NULL;
3036       ret->datalabel_got_offset = (bfd_vma) -1;
3037     }
3038
3039   return (struct bfd_hash_entry *) ret;
3040 }
3041
3042 /* Create an sh64 ELF linker hash table.  */
3043
3044 static struct bfd_link_hash_table *
3045 sh64_elf64_link_hash_table_create (bfd *abfd)
3046 {
3047   struct elf_link_hash_table *ret;
3048
3049   ret = (struct elf_link_hash_table *) bfd_zmalloc (sizeof (* ret));
3050   if (ret == (struct elf_link_hash_table *) NULL)
3051     return NULL;
3052
3053   if (!_bfd_elf_link_hash_table_init (ret, abfd,
3054                                       sh64_elf64_link_hash_newfunc,
3055                                       sizeof (struct elf_sh64_link_hash_entry),
3056                                       GENERIC_ELF_DATA))
3057     {
3058       free (ret);
3059       return NULL;
3060     }
3061
3062   return &ret->root;
3063 }
3064
3065 inline static void
3066 movi_shori_putval (bfd *output_bfd, unsigned long value, bfd_byte *addr)
3067 {
3068   bfd_put_32 (output_bfd,
3069               bfd_get_32 (output_bfd, addr)
3070               | ((value >> 6) & 0x3fffc00),
3071               addr);
3072   bfd_put_32 (output_bfd,
3073               bfd_get_32 (output_bfd, addr + 4)
3074               | ((value << 10) & 0x3fffc00),
3075               addr + 4);
3076 }
3077
3078 inline static void
3079 movi_3shori_putval (bfd *output_bfd, bfd_vma value, bfd_byte *addr)
3080 {
3081   bfd_put_32 (output_bfd,
3082               bfd_get_32 (output_bfd, addr)
3083               | ((value >> 38) & 0x3fffc00),
3084               addr);
3085   bfd_put_32 (output_bfd,
3086               bfd_get_32 (output_bfd, addr + 4)
3087               | ((value >> 22) & 0x3fffc00),
3088               addr + 4);
3089   bfd_put_32 (output_bfd,
3090               bfd_get_32 (output_bfd, addr + 8)
3091               | ((value >> 6) & 0x3fffc00),
3092               addr + 8);
3093   bfd_put_32 (output_bfd,
3094               bfd_get_32 (output_bfd, addr + 12)
3095               | ((value << 10) & 0x3fffc00),
3096               addr + 12);
3097 }
3098
3099 /* Create dynamic sections when linking against a dynamic object.  */
3100
3101 static bfd_boolean
3102 sh64_elf64_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3103 {
3104   flagword flags, pltflags;
3105   register asection *s;
3106   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3107   int ptralign = 0;
3108
3109   switch (bed->s->arch_size)
3110     {
3111     case 32:
3112       ptralign = 2;
3113       break;
3114
3115     case 64:
3116       ptralign = 3;
3117       break;
3118
3119     default:
3120       bfd_set_error (bfd_error_bad_value);
3121       return FALSE;
3122     }
3123
3124   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3125      .rel[a].bss sections.  */
3126
3127   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3128            | SEC_LINKER_CREATED);
3129
3130   pltflags = flags;
3131   pltflags |= SEC_CODE;
3132   if (bed->plt_not_loaded)
3133     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3134   if (bed->plt_readonly)
3135     pltflags |= SEC_READONLY;
3136
3137   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
3138   if (s == NULL
3139       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3140     return FALSE;
3141
3142   if (bed->want_plt_sym)
3143     {
3144       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3145          .plt section.  */
3146       struct elf_link_hash_entry *h;
3147       struct bfd_link_hash_entry *bh = NULL;
3148
3149       if (! (_bfd_generic_link_add_one_symbol
3150              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3151               (bfd_vma) 0, (const char *) NULL, FALSE, bed->collect, &bh)))
3152         return FALSE;
3153
3154       h = (struct elf_link_hash_entry *) bh;
3155       h->def_regular = 1;
3156       h->type = STT_OBJECT;
3157       elf_hash_table (info)->hplt = h;
3158
3159       if (bfd_link_pic (info)
3160           && ! bfd_elf_link_record_dynamic_symbol (info, h))
3161         return FALSE;
3162     }
3163
3164   s = bfd_make_section_anyway_with_flags (abfd,
3165                                           bed->default_use_rela_p
3166                                           ? ".rela.plt" : ".rel.plt",
3167                                           flags | SEC_READONLY);
3168   if (s == NULL
3169       || ! bfd_set_section_alignment (abfd, s, ptralign))
3170     return FALSE;
3171
3172   if (! _bfd_elf_create_got_section (abfd, info))
3173     return FALSE;
3174
3175   if (bed->want_dynbss)
3176     {
3177       /* The .dynbss section is a place to put symbols which are defined
3178          by dynamic objects, are referenced by regular objects, and are
3179          not functions.  We must allocate space for them in the process
3180          image and use a R_*_COPY reloc to tell the dynamic linker to
3181          initialize them at run time.  The linker script puts the .dynbss
3182          section into the .bss section of the final image.  */
3183       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
3184                                               SEC_ALLOC | SEC_LINKER_CREATED);
3185       if (s == NULL)
3186         return FALSE;
3187
3188       /* The .rel[a].bss section holds copy relocs.  This section is not
3189          normally needed.  We need to create it here, though, so that the
3190          linker will map it to an output section.  We can't just create it
3191          only if we need it, because we will not know whether we need it
3192          until we have seen all the input files, and the first time the
3193          main linker code calls BFD after examining all the input files
3194          (size_dynamic_sections) the input sections have already been
3195          mapped to the output sections.  If the section turns out not to
3196          be needed, we can discard it later.  We will never need this
3197          section when generating a shared object, since they do not use
3198          copy relocs.  */
3199       if (! bfd_link_pic (info))
3200         {
3201           s = bfd_make_section_anyway_with_flags (abfd,
3202                                                   (bed->default_use_rela_p
3203                                                    ? ".rela.bss" : ".rel.bss"),
3204                                                   flags | SEC_READONLY);
3205           if (s == NULL
3206               || ! bfd_set_section_alignment (abfd, s, ptralign))
3207             return FALSE;
3208         }
3209     }
3210
3211   return TRUE;
3212 }
3213 \f
3214 /* Adjust a symbol defined by a dynamic object and referenced by a
3215    regular object.  The current definition is in some section of the
3216    dynamic object, but we're not including those sections.  We have to
3217    change the definition to something the rest of the link can
3218    understand.  */
3219
3220 static bfd_boolean
3221 sh64_elf64_adjust_dynamic_symbol (struct bfd_link_info *info,
3222                                   struct elf_link_hash_entry *h)
3223 {
3224   bfd *dynobj;
3225   asection *s;
3226
3227   dynobj = elf_hash_table (info)->dynobj;
3228
3229   /* Make sure we know what is going on here.  */
3230   BFD_ASSERT (dynobj != NULL
3231               && (h->needs_plt
3232                   || h->u.weakdef != NULL
3233                   || (h->def_dynamic
3234                       && h->ref_regular
3235                       && !h->def_regular)));
3236
3237   /* If this is a function, put it in the procedure linkage table.  We
3238      will fill in the contents of the procedure linkage table later,
3239      when we know the address of the .got section.  */
3240   if (h->type == STT_FUNC
3241       || h->needs_plt)
3242     {
3243       if (! bfd_link_pic (info)
3244           && !h->def_dynamic
3245           && !h->ref_dynamic)
3246         {
3247           /* This case can occur if we saw a PLT reloc in an input
3248              file, but the symbol was never referred to by a dynamic
3249              object.  In such a case, we don't actually need to build
3250              a procedure linkage table, and we can just do a REL64
3251              reloc instead.  */
3252           BFD_ASSERT (h->needs_plt);
3253           return TRUE;
3254         }
3255
3256       /* Make sure this symbol is output as a dynamic symbol.  */
3257       if (h->dynindx == -1)
3258         {
3259           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3260             return FALSE;
3261         }
3262
3263       s = bfd_get_linker_section (dynobj, ".plt");
3264       BFD_ASSERT (s != NULL);
3265
3266       /* If this is the first .plt entry, make room for the special
3267          first entry.  */
3268       if (s->size == 0)
3269         s->size += PLT_ENTRY_SIZE;
3270
3271       /* If this symbol is not defined in a regular file, and we are
3272          not generating a shared library, then set the symbol to this
3273          location in the .plt.  This is required to make function
3274          pointers compare as equal between the normal executable and
3275          the shared library.  */
3276       if (! bfd_link_pic (info)
3277           && !h->def_regular)
3278         {
3279           h->root.u.def.section = s;
3280           h->root.u.def.value = s->size;
3281         }
3282
3283       h->plt.offset = s->size;
3284
3285       /* Make room for this entry.  */
3286       s->size += elf_sh64_sizeof_plt (info);
3287
3288       /* We also need to make an entry in the .got.plt section, which
3289          will be placed in the .got section by the linker script.  */
3290
3291       s = bfd_get_linker_section (dynobj, ".got.plt");
3292       BFD_ASSERT (s != NULL);
3293       s->size += 8;
3294
3295       /* We also need to make an entry in the .rela.plt section.  */
3296
3297       s = bfd_get_linker_section (dynobj, ".rela.plt");
3298       BFD_ASSERT (s != NULL);
3299       s->size += sizeof (Elf64_External_Rela);
3300
3301       return TRUE;
3302     }
3303
3304   /* If this is a weak symbol, and there is a real definition, the
3305      processor independent code will have arranged for us to see the
3306      real definition first, and we can just use the same value.  */
3307   if (h->u.weakdef != NULL)
3308     {
3309       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3310                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
3311       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3312       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3313       return TRUE;
3314     }
3315
3316   /* This is a reference to a symbol defined by a dynamic object which
3317      is not a function.  */
3318
3319   /* If we are creating a shared library, we must presume that the
3320      only references to the symbol are via the global offset table.
3321      For such cases we need not do anything here; the relocations will
3322      be handled correctly by relocate_section.  */
3323   if (bfd_link_pic (info))
3324     return TRUE;
3325
3326   /* If there are no references to this symbol that do not use the
3327      GOT, we don't need to generate a copy reloc.  */
3328   if (!h->non_got_ref)
3329     return TRUE;
3330
3331   /* We must allocate the symbol in our .dynbss section, which will
3332      become part of the .bss section of the executable.  There will be
3333      an entry for this symbol in the .dynsym section.  The dynamic
3334      object will contain position independent code, so all references
3335      from the dynamic object to this symbol will go through the global
3336      offset table.  The dynamic linker will use the .dynsym entry to
3337      determine the address it must put in the global offset table, so
3338      both the dynamic object and the regular object will refer to the
3339      same memory location for the variable.  */
3340
3341   s = bfd_get_linker_section (dynobj, ".dynbss");
3342   BFD_ASSERT (s != NULL);
3343
3344   /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
3345      copy the initial value out of the dynamic object and into the
3346      runtime process image.  We need to remember the offset into the
3347      .rela.bss section we are going to use.  */
3348   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3349     {
3350       asection *srel;
3351
3352       srel = bfd_get_linker_section (dynobj, ".rela.bss");
3353       BFD_ASSERT (srel != NULL);
3354       srel->size += sizeof (Elf64_External_Rela);
3355       h->needs_copy = 1;
3356     }
3357
3358   return _bfd_elf_adjust_dynamic_copy (info, h, s);
3359 }
3360
3361 /* This function is called via sh_elf_link_hash_traverse if we are
3362    creating a shared object with -Bsymbolic.  It discards the space
3363    allocated to copy PC relative relocs against symbols which are
3364    defined in regular objects.  We allocated space for them in the
3365    check_relocs routine, but we won't fill them in in the
3366    relocate_section routine.  */
3367
3368 static bfd_boolean
3369 sh64_elf64_discard_copies (struct elf_sh64_link_hash_entry *h,
3370                            void *ignore ATTRIBUTE_UNUSED)
3371 {
3372   struct elf_sh64_pcrel_relocs_copied *s;
3373
3374   /* We only discard relocs for symbols defined in a regular object.  */
3375   if (!h->root.def_regular)
3376     return TRUE;
3377
3378   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3379     s->section->size -= s->count * sizeof (Elf64_External_Rela);
3380
3381   return TRUE;
3382 }
3383
3384 /* Set the sizes of the dynamic sections.  */
3385
3386 static bfd_boolean
3387 sh64_elf64_size_dynamic_sections (bfd *output_bfd,
3388                                   struct bfd_link_info *info)
3389 {
3390   bfd *dynobj;
3391   asection *s;
3392   bfd_boolean plt;
3393   bfd_boolean relocs;
3394   bfd_boolean reltext;
3395
3396   dynobj = elf_hash_table (info)->dynobj;
3397   BFD_ASSERT (dynobj != NULL);
3398
3399   if (elf_hash_table (info)->dynamic_sections_created)
3400     {
3401       /* Set the contents of the .interp section to the interpreter.  */
3402       if (bfd_link_executable (info) && !info->nointerp)
3403         {
3404           s = bfd_get_linker_section (dynobj, ".interp");
3405           BFD_ASSERT (s != NULL);
3406           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3407           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3408         }
3409     }
3410   else
3411     {
3412       /* We may have created entries in the .rela.got section.
3413          However, if we are not creating the dynamic sections, we will
3414          not actually use these entries.  Reset the size of .rela.got,
3415          which will cause it to get stripped from the output file
3416          below.  */
3417       s = bfd_get_linker_section (dynobj, ".rela.got");
3418       if (s != NULL)
3419         s->size = 0;
3420     }
3421
3422   /* If this is a -Bsymbolic shared link, then we need to discard all
3423      PC relative relocs against symbols defined in a regular object.
3424      We allocated space for them in the check_relocs routine, but we
3425      will not fill them in in the relocate_section routine.  */
3426   if (bfd_link_pic (info) && info->symbolic)
3427     sh64_elf64_link_hash_traverse (elf_hash_table (info),
3428                                    sh64_elf64_discard_copies, NULL);
3429
3430   /* The check_relocs and adjust_dynamic_symbol entry points have
3431      determined the sizes of the various dynamic sections.  Allocate
3432      memory for them.  */
3433   plt = FALSE;
3434   relocs = FALSE;
3435   reltext = FALSE;
3436   for (s = dynobj->sections; s != NULL; s = s->next)
3437     {
3438       const char *name;
3439
3440       if ((s->flags & SEC_LINKER_CREATED) == 0)
3441         continue;
3442
3443       /* It's OK to base decisions on the section name, because none
3444          of the dynobj section names depend upon the input files.  */
3445       name = bfd_get_section_name (dynobj, s);
3446
3447       if (strcmp (name, ".plt") == 0)
3448         {
3449           /* Remember whether there is a PLT.  */
3450           plt = s->size != 0;
3451         }
3452       else if (CONST_STRNEQ (name, ".rela"))
3453         {
3454           if (s->size != 0)
3455             {
3456               asection *target;
3457
3458               /* Remember whether there are any reloc sections other
3459                  than .rela.plt.  */
3460               if (strcmp (name, ".rela.plt") != 0)
3461                 {
3462                   const char *outname;
3463
3464                   relocs = TRUE;
3465
3466                   /* If this relocation section applies to a read only
3467                      section, then we probably need a DT_TEXTREL
3468                      entry.  The entries in the .rela.plt section
3469                      really apply to the .got section, which we
3470                      created ourselves and so know is not readonly.  */
3471                   outname = bfd_get_section_name (output_bfd,
3472                                                   s->output_section);
3473                   target = bfd_get_section_by_name (output_bfd, outname + 5);
3474                   if (target != NULL
3475                       && (target->flags & SEC_READONLY) != 0
3476                       && (target->flags & SEC_ALLOC) != 0)
3477                     reltext = TRUE;
3478                 }
3479
3480               /* We use the reloc_count field as a counter if we need
3481                  to copy relocs into the output file.  */
3482               s->reloc_count = 0;
3483             }
3484         }
3485       else if (! CONST_STRNEQ (name, ".got")
3486                && strcmp (name, ".dynbss") != 0)
3487         {
3488           /* It's not one of our sections, so don't allocate space.  */
3489           continue;
3490         }
3491
3492       if (s->size == 0)
3493         {
3494           /* If we don't need this section, strip it from the
3495              output file.  This is mostly to handle .rela.bss and
3496              .rela.plt.  We must create both sections in
3497              create_dynamic_sections, because they must be created
3498              before the linker maps input sections to output
3499              sections.  The linker does that before
3500              adjust_dynamic_symbol is called, and it is that
3501              function which decides whether anything needs to go
3502              into these sections.  */
3503           s->flags |= SEC_EXCLUDE;
3504           continue;
3505         }
3506
3507       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3508         continue;
3509
3510       /* Allocate memory for the section contents.  */
3511       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3512       if (s->contents == NULL)
3513         return FALSE;
3514     }
3515
3516   if (elf_hash_table (info)->dynamic_sections_created)
3517     {
3518       /* Add some entries to the .dynamic section.  We fill in the
3519          values later, in sh64_elf64_finish_dynamic_sections, but we
3520          must add the entries now so that we get the correct size for
3521          the .dynamic section.  The DT_DEBUG entry is filled in by the
3522          dynamic linker and used by the debugger.  */
3523       if (bfd_link_executable (info))
3524         {
3525           if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
3526             return FALSE;
3527         }
3528
3529       if (plt)
3530         {
3531           if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
3532               || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3533               || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3534               || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
3535             return FALSE;
3536         }
3537
3538       if (relocs)
3539         {
3540           if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
3541               || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
3542               || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
3543                                               sizeof (Elf64_External_Rela)))
3544             return FALSE;
3545         }
3546
3547       if (reltext)
3548         {
3549           if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
3550             return FALSE;
3551         }
3552     }
3553
3554   return TRUE;
3555 }
3556
3557 /* Finish up dynamic symbol handling.  We set the contents of various
3558    dynamic sections here.  */
3559
3560 static bfd_boolean
3561 sh64_elf64_finish_dynamic_symbol (bfd *output_bfd,
3562                                   struct bfd_link_info *info,
3563                                   struct elf_link_hash_entry *h,
3564                                   Elf_Internal_Sym *sym)
3565 {
3566   bfd *dynobj;
3567
3568   dynobj = elf_hash_table (info)->dynobj;
3569
3570   if (h->plt.offset != (bfd_vma) -1)
3571     {
3572       asection *splt;
3573       asection *sgot;
3574       asection *srel;
3575
3576       bfd_vma plt_index;
3577       bfd_vma got_offset;
3578       Elf_Internal_Rela rel;
3579       bfd_byte *loc;
3580
3581       /* This symbol has an entry in the procedure linkage table.  Set
3582          it up.  */
3583
3584       BFD_ASSERT (h->dynindx != -1);
3585
3586       splt = bfd_get_linker_section (dynobj, ".plt");
3587       sgot = bfd_get_linker_section (dynobj, ".got.plt");
3588       srel = bfd_get_linker_section (dynobj, ".rela.plt");
3589       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3590
3591       /* Get the index in the procedure linkage table which
3592          corresponds to this symbol.  This is the index of this symbol
3593          in all the symbols for which we are making plt entries.  The
3594          first entry in the procedure linkage table is reserved.  */
3595       plt_index = h->plt.offset / elf_sh64_sizeof_plt (info) - 1;
3596
3597       /* Get the offset into the .got table of the entry that
3598          corresponds to this function.  Each .got entry is 8 bytes.
3599          The first three are reserved.  */
3600       got_offset = (plt_index + 3) * 8;
3601
3602       if (bfd_link_pic (info))
3603         got_offset -= GOT_BIAS;
3604
3605       /* Fill in the entry in the procedure linkage table.  */
3606       if (! bfd_link_pic (info))
3607         {
3608           if (elf_sh64_plt_entry == NULL)
3609             {
3610               elf_sh64_plt_entry = (bfd_big_endian (output_bfd) ?
3611                                   elf_sh64_plt_entry_be : elf_sh64_plt_entry_le);
3612             }
3613           memcpy (splt->contents + h->plt.offset, elf_sh64_plt_entry,
3614                   elf_sh64_sizeof_plt (info));
3615           movi_3shori_putval (output_bfd,
3616                               (sgot->output_section->vma
3617                                + sgot->output_offset
3618                                + got_offset),
3619                               (splt->contents + h->plt.offset
3620                                + elf_sh64_plt_symbol_offset (info)));
3621
3622           /* Set bottom bit because its for a branch to SHmedia */
3623           movi_shori_putval (output_bfd,
3624                              -(h->plt.offset
3625                               + elf_sh64_plt_plt0_offset (info) + 8)
3626                              | 1,
3627                              (splt->contents + h->plt.offset
3628                               + elf_sh64_plt_plt0_offset (info)));
3629         }
3630       else
3631         {
3632           if (elf_sh64_pic_plt_entry == NULL)
3633             {
3634               elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3635                                       elf_sh64_pic_plt_entry_be :
3636                                       elf_sh64_pic_plt_entry_le);
3637             }
3638           memcpy (splt->contents + h->plt.offset, elf_sh64_pic_plt_entry,
3639                   elf_sh64_sizeof_plt (info));
3640           movi_shori_putval (output_bfd, got_offset,
3641                              (splt->contents + h->plt.offset
3642                               + elf_sh64_plt_symbol_offset (info)));
3643         }
3644
3645       if (bfd_link_pic (info))
3646         got_offset += GOT_BIAS;
3647
3648       movi_shori_putval (output_bfd,
3649                          plt_index * sizeof (Elf64_External_Rela),
3650                          (splt->contents + h->plt.offset
3651                           + elf_sh64_plt_reloc_offset (info)));
3652
3653       /* Fill in the entry in the global offset table.  */
3654       bfd_put_64 (output_bfd,
3655                   (splt->output_section->vma
3656                    + splt->output_offset
3657                    + h->plt.offset
3658                    + elf_sh64_plt_temp_offset (info)),
3659                   sgot->contents + got_offset);
3660
3661       /* Fill in the entry in the .rela.plt section.  */
3662       rel.r_offset = (sgot->output_section->vma
3663                       + sgot->output_offset
3664                       + got_offset);
3665       rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_JMP_SLOT64);
3666       rel.r_addend = 0;
3667       rel.r_addend = GOT_BIAS;
3668       loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
3669       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3670
3671       if (!h->def_regular)
3672         {
3673           /* Mark the symbol as undefined, rather than as defined in
3674              the .plt section.  Leave the value alone.  */
3675           sym->st_shndx = SHN_UNDEF;
3676         }
3677     }
3678
3679   if (h->got.offset != (bfd_vma) -1)
3680     {
3681       asection *sgot;
3682       asection *srel;
3683       Elf_Internal_Rela rel;
3684       bfd_byte *loc;
3685
3686       /* This symbol has an entry in the global offset table.  Set it
3687          up.  */
3688
3689       sgot = bfd_get_linker_section (dynobj, ".got");
3690       srel = bfd_get_linker_section (dynobj, ".rela.got");
3691       BFD_ASSERT (sgot != NULL && srel != NULL);
3692
3693       rel.r_offset = (sgot->output_section->vma
3694                       + sgot->output_offset
3695                       + (h->got.offset &~ 1));
3696
3697       /* If this is a -Bsymbolic link, and the symbol is defined
3698          locally, we just want to emit a RELATIVE reloc.  Likewise if
3699          the symbol was forced to be local because of a version file.
3700          The entry in the global offset table will already have been
3701          initialized in the relocate_section function.  */
3702       if (bfd_link_pic (info)
3703           && (info->symbolic || h->dynindx == -1)
3704           && h->def_regular)
3705         {
3706           rel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
3707           rel.r_addend = (h->root.u.def.value
3708                           + h->root.u.def.section->output_section->vma
3709                           + h->root.u.def.section->output_offset);
3710         }
3711       else
3712         {
3713           bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3714           rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_GLOB_DAT64);
3715           rel.r_addend = 0;
3716         }
3717
3718       loc = srel->contents;
3719       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
3720       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3721     }
3722
3723   if (h->needs_copy)
3724     {
3725       asection *s;
3726       Elf_Internal_Rela rel;
3727       bfd_byte *loc;
3728
3729       /* This symbol needs a copy reloc.  Set it up.  */
3730
3731       BFD_ASSERT (h->dynindx != -1
3732                   && (h->root.type == bfd_link_hash_defined
3733                       || h->root.type == bfd_link_hash_defweak));
3734
3735       s = bfd_get_linker_section (dynobj, ".rela.bss");
3736       BFD_ASSERT (s != NULL);
3737
3738       rel.r_offset = (h->root.u.def.value
3739                       + h->root.u.def.section->output_section->vma
3740                       + h->root.u.def.section->output_offset);
3741       rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_COPY64);
3742       rel.r_addend = 0;
3743       loc = s->contents;
3744       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
3745       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3746     }
3747
3748   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3749   if (h == elf_hash_table (info)->hdynamic
3750       || h == elf_hash_table (info)->hgot)
3751     sym->st_shndx = SHN_ABS;
3752
3753   return TRUE;
3754 }
3755
3756 /* Finish up the dynamic sections.  */
3757
3758 static bfd_boolean
3759 sh64_elf64_finish_dynamic_sections (bfd *output_bfd,
3760                                     struct bfd_link_info *info)
3761 {
3762   bfd *dynobj;
3763   asection *sgot;
3764   asection *sdyn;
3765
3766   dynobj = elf_hash_table (info)->dynobj;
3767
3768   sgot = bfd_get_linker_section (dynobj, ".got.plt");
3769   BFD_ASSERT (sgot != NULL);
3770   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3771
3772   if (elf_hash_table (info)->dynamic_sections_created)
3773     {
3774       asection *splt;
3775       Elf64_External_Dyn *dyncon, *dynconend;
3776
3777       BFD_ASSERT (sdyn != NULL);
3778
3779       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3780       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3781       for (; dyncon < dynconend; dyncon++)
3782         {
3783           Elf_Internal_Dyn dyn;
3784           const char *name;
3785           asection *s;
3786           struct elf_link_hash_entry *h;
3787
3788           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3789
3790           switch (dyn.d_tag)
3791             {
3792             default:
3793               break;
3794
3795             case DT_INIT:
3796               name = info->init_function;
3797               goto get_sym;
3798
3799             case DT_FINI:
3800               name = info->fini_function;
3801             get_sym:
3802               if (dyn.d_un.d_val != 0)
3803                 {
3804                   h = elf_link_hash_lookup (elf_hash_table (info), name,
3805                                             FALSE, FALSE, TRUE);
3806                   if (h != NULL && (h->other & STO_SH5_ISA32))
3807                     {
3808                       dyn.d_un.d_val |= 1;
3809                       bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3810                     }
3811                 }
3812               break;
3813
3814             case DT_PLTGOT:
3815               name = ".got.plt";
3816               goto get_vma;
3817
3818             case DT_JMPREL:
3819               name = ".rela.plt";
3820             get_vma:
3821               s = bfd_get_linker_section (dynobj, name);
3822               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3823               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3824               break;
3825
3826             case DT_PLTRELSZ:
3827               s = bfd_get_linker_section (dynobj, ".rela.plt");
3828               dyn.d_un.d_val = s->size;
3829               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3830               break;
3831
3832             case DT_RELASZ:
3833               /* My reading of the SVR4 ABI indicates that the
3834                  procedure linkage table relocs (DT_JMPREL) should be
3835                  included in the overall relocs (DT_RELA).  This is
3836                  what Solaris does.  However, UnixWare can not handle
3837                  that case.  Therefore, we override the DT_RELASZ entry
3838                  here to make it not include the JMPREL relocs.  Since
3839                  the linker script arranges for .rela.plt to follow all
3840                  other relocation sections, we don't have to worry
3841                  about changing the DT_RELA entry.  */
3842               s = bfd_get_linker_section (dynobj, ".rela.plt");
3843               if (s != NULL)
3844                 dyn.d_un.d_val -= s->size;
3845               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3846               break;
3847             }
3848         }
3849
3850       /* Fill in the first entry in the procedure linkage table.  */
3851       splt = bfd_get_linker_section (dynobj, ".plt");
3852       if (splt && splt->size > 0)
3853         {
3854           if (bfd_link_pic (info))
3855             {
3856               if (elf_sh64_pic_plt_entry == NULL)
3857                 {
3858                   elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3859                                           elf_sh64_pic_plt_entry_be :
3860                                           elf_sh64_pic_plt_entry_le);
3861                 }
3862               memcpy (splt->contents, elf_sh64_pic_plt_entry,
3863                       elf_sh64_sizeof_plt (info));
3864             }
3865           else
3866             {
3867               if (elf_sh64_plt0_entry == NULL)
3868                 {
3869                   elf_sh64_plt0_entry = (bfd_big_endian (output_bfd) ?
3870                                        elf_sh64_plt0_entry_be :
3871                                        elf_sh64_plt0_entry_le);
3872                 }
3873               memcpy (splt->contents, elf_sh64_plt0_entry, PLT_ENTRY_SIZE);
3874               movi_3shori_putval (output_bfd,
3875                                   sgot->output_section->vma
3876                                   + sgot->output_offset,
3877                                   splt->contents
3878                                   + elf_sh64_plt0_gotplt_offset (info));
3879             }
3880
3881           /* UnixWare sets the entsize of .plt to 8, although that doesn't
3882              really seem like the right value.  */
3883           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 8;
3884         }
3885     }
3886
3887   /* Fill in the first three entries in the global offset table.  */
3888   if (sgot->size > 0)
3889     {
3890       if (sdyn == NULL)
3891         bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
3892       else
3893         bfd_put_64 (output_bfd,
3894                     sdyn->output_section->vma + sdyn->output_offset,
3895                     sgot->contents);
3896       bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3897       bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 16);
3898     }
3899
3900   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
3901
3902   return TRUE;
3903 }
3904
3905 /* Merge non visibility st_other attribute when the symbol comes from
3906    a dynamic object.  */
3907 static void
3908 sh64_elf64_merge_symbol_attribute (struct elf_link_hash_entry *h,
3909                                    const Elf_Internal_Sym *isym,
3910                                    bfd_boolean definition,
3911                                    bfd_boolean dynamic ATTRIBUTE_UNUSED)
3912 {
3913   if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
3914     {
3915       unsigned char other;
3916
3917       /* Take the balance of OTHER from the definition.  */
3918       other = (definition ? isym->st_other : h->other);
3919       other &= ~ ELF_ST_VISIBILITY (-1);
3920       h->other = other | ELF_ST_VISIBILITY (h->other);
3921     }
3922
3923   return;
3924 }
3925
3926 static const struct bfd_elf_special_section sh64_elf64_special_sections[]=
3927 {
3928   { STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 },
3929   { NULL,                       0, 0, 0,            0 }
3930 };
3931
3932 #define TARGET_BIG_SYM          sh64_elf64_vec
3933 #define TARGET_BIG_NAME         "elf64-sh64"
3934 #define TARGET_LITTLE_SYM       sh64_elf64_le_vec
3935 #define TARGET_LITTLE_NAME      "elf64-sh64l"
3936 #define ELF_ARCH                bfd_arch_sh
3937 #define ELF_MACHINE_CODE        EM_SH
3938 #define ELF_MAXPAGESIZE         128
3939
3940 #define elf_symbol_leading_char '_'
3941
3942 #define bfd_elf64_bfd_reloc_type_lookup sh_elf64_reloc_type_lookup
3943 #define bfd_elf64_bfd_reloc_name_lookup \
3944                                         sh_elf64_reloc_name_lookup
3945 #define elf_info_to_howto               sh_elf64_info_to_howto
3946
3947 /* Note: there's no relaxation at present.  */
3948
3949 #define elf_backend_relocate_section    sh_elf64_relocate_section
3950 #define bfd_elf64_bfd_get_relocated_section_contents \
3951                                         sh_elf64_get_relocated_section_contents
3952 #define elf_backend_object_p            sh_elf64_set_mach_from_flags
3953 #define bfd_elf64_bfd_set_private_flags \
3954                                         sh_elf64_set_private_flags
3955 #define bfd_elf64_bfd_copy_private_bfd_data \
3956                                         sh_elf64_copy_private_data
3957 #define bfd_elf64_bfd_merge_private_bfd_data \
3958                                         sh_elf64_merge_private_data
3959 #define elf_backend_fake_sections       sh64_elf64_fake_sections
3960
3961 #define elf_backend_gc_mark_hook        sh_elf64_gc_mark_hook
3962 #define elf_backend_check_relocs        sh_elf64_check_relocs
3963
3964 #define elf_backend_can_gc_sections     1
3965
3966 #define elf_backend_get_symbol_type     sh64_elf64_get_symbol_type
3967
3968 #define elf_backend_add_symbol_hook     sh64_elf64_add_symbol_hook
3969
3970 #define elf_backend_link_output_symbol_hook \
3971         sh64_elf64_link_output_symbol_hook
3972
3973 #define elf_backend_merge_symbol_attribute \
3974         sh64_elf64_merge_symbol_attribute
3975
3976 #define elf_backend_final_write_processing \
3977         sh64_elf64_final_write_processing
3978
3979 #define elf_backend_create_dynamic_sections \
3980                                         sh64_elf64_create_dynamic_sections
3981 #define bfd_elf64_bfd_link_hash_table_create \
3982                                         sh64_elf64_link_hash_table_create
3983 #define elf_backend_adjust_dynamic_symbol \
3984                                         sh64_elf64_adjust_dynamic_symbol
3985 #define elf_backend_size_dynamic_sections \
3986                                         sh64_elf64_size_dynamic_sections
3987 #define elf_backend_omit_section_dynsym \
3988   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
3989 #define elf_backend_finish_dynamic_symbol \
3990                                         sh64_elf64_finish_dynamic_symbol
3991 #define elf_backend_finish_dynamic_sections \
3992                                         sh64_elf64_finish_dynamic_sections
3993 #define elf_backend_special_sections    sh64_elf64_special_sections
3994
3995 #define elf_backend_want_got_plt        1
3996 #define elf_backend_plt_readonly        1
3997 #define elf_backend_want_plt_sym        0
3998 #define elf_backend_got_header_size     24
3999
4000 #include "elf64-target.h"
4001
4002 /* NetBSD support.  */
4003 #undef  TARGET_BIG_SYM
4004 #define TARGET_BIG_SYM                  sh64_elf64_nbsd_vec
4005 #undef  TARGET_BIG_NAME
4006 #define TARGET_BIG_NAME                 "elf64-sh64-nbsd"
4007 #undef  TARGET_LITTLE_SYM
4008 #define TARGET_LITTLE_SYM               sh64_elf64_nbsd_le_vec
4009 #undef  TARGET_LITTLE_NAME
4010 #define TARGET_LITTLE_NAME              "elf64-sh64l-nbsd"
4011 #undef  ELF_MAXPAGESIZE
4012 #define ELF_MAXPAGESIZE                 0x10000
4013 #undef  elf_symbol_leading_char
4014 #define elf_symbol_leading_char         0
4015
4016 #define elf64_bed                       elf64_sh64_nbsd_bed
4017
4018 #include "elf64-target.h"
4019
4020 /* Linux support.  */
4021 #undef  TARGET_BIG_SYM
4022 #define TARGET_BIG_SYM                  sh64_elf64_linux_be_vec
4023 #undef  TARGET_BIG_NAME
4024 #define TARGET_BIG_NAME                 "elf64-sh64big-linux"
4025 #undef  TARGET_LITTLE_SYM
4026 #define TARGET_LITTLE_SYM               sh64_elf64_linux_vec
4027 #undef  TARGET_LITTLE_NAME
4028 #define TARGET_LITTLE_NAME              "elf64-sh64-linux"
4029 #undef elf64_bed
4030 #define elf64_bed                       elf64_sh64_linux_bed
4031
4032 #include "elf64-target.h"