bfd/elf64-sh64.c

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