bfd/elf64-sh64.c

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