bfd/elf64-sh64.c

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