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