bfd/elf64-sh64.c

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