bfd/elf32-sh.c

   1 /* Hitachi SH specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4    Contributed by Ian Lance Taylor, Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  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 static bfd_reloc_status_type sh_elf_reloc
  30   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  31 static bfd_reloc_status_type sh_elf_ignore_reloc
  32   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  33 static reloc_howto_type *sh_elf_reloc_type_lookup
  34   PARAMS ((bfd *, bfd_reloc_code_real_type));
  35 static void sh_elf_info_to_howto
  36   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  37 static boolean sh_elf_set_private_flags
  38   PARAMS ((bfd *, flagword));
  39 static boolean sh_elf_copy_private_data
  40   PARAMS ((bfd *, bfd *));
  41 static boolean sh_elf_merge_private_data
  42   PARAMS ((bfd *, bfd *));
  43 static boolean sh_elf_set_mach_from_flags
  44   PARAMS ((bfd *));
  45 static boolean sh_elf_relax_section
  46   PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
  47 static boolean sh_elf_relax_delete_bytes
  48   PARAMS ((bfd *, asection *, bfd_vma, int));
  49 static boolean sh_elf_align_loads
  50   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, boolean *));
  51 static boolean sh_elf_swap_insns
  52   PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
  53 static boolean sh_elf_relocate_section
  54   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  55            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  56 static bfd_byte *sh_elf_get_relocated_section_contents
  57   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
  58            bfd_byte *, boolean, asymbol **));
  59 static void sh_elf_copy_indirect_symbol
  60   PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
  61            struct elf_link_hash_entry *));
  62 static int sh_elf_optimized_tls_reloc
  63   PARAMS ((struct bfd_link_info *, int, int));
  64 static boolean sh_elf_mkobject
  65   PARAMS((bfd *));
  66 static boolean sh_elf_object_p
  67   PARAMS((bfd *));
  68 static boolean sh_elf_check_relocs
  69   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  70            const Elf_Internal_Rela *));
  71 static struct bfd_hash_entry *sh_elf_link_hash_newfunc
  72   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  73 static struct bfd_link_hash_table *sh_elf_link_hash_table_create
  74   PARAMS ((bfd *));
  75 static boolean sh_elf_adjust_dynamic_symbol
  76   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  77 static boolean sh_elf_size_dynamic_sections
  78   PARAMS ((bfd *, struct bfd_link_info *));
  79 static boolean sh_elf_finish_dynamic_symbol
  80   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  81            Elf_Internal_Sym *));
  82 static boolean sh_elf_finish_dynamic_sections
  83   PARAMS ((bfd *, struct bfd_link_info *));
  84 static bfd_reloc_status_type sh_elf_reloc_loop
  85   PARAMS ((int, bfd *, asection *, bfd_byte *, bfd_vma, asection *,
  86            bfd_vma, bfd_vma));
  87 static boolean create_got_section
  88   PARAMS((bfd *, struct bfd_link_info *));
  89 static boolean sh_elf_create_dynamic_sections
  90   PARAMS ((bfd *, struct bfd_link_info *));
  91 static bfd_vma dtpoff_base
  92   PARAMS ((struct bfd_link_info *));
  93 static asection * sh_elf_gc_mark_hook
  94   PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  95            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  96 static boolean sh_elf_gc_sweep_hook
  97   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  98            const Elf_Internal_Rela *));
  99 static boolean allocate_dynrelocs
 100   PARAMS ((struct elf_link_hash_entry *, PTR));
 101 static boolean readonly_dynrelocs
 102   PARAMS ((struct elf_link_hash_entry *, PTR));
 103 static enum elf_reloc_type_class sh_elf_reloc_type_class
 104   PARAMS ((const Elf_Internal_Rela *));
 105 #ifdef INCLUDE_SHMEDIA
 106 inline static void movi_shori_putval PARAMS ((bfd *, unsigned long, char *));
 107 #endif
 108 static boolean elf32_shlin_grok_prstatus
 109   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
 110 static boolean elf32_shlin_grok_psinfo
 111   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
 112
 113 /* The name of the dynamic interpreter.  This is put in the .interp
 114    section.  */
 115
 116 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 117
 118 static reloc_howto_type sh_elf_howto_table[] =
 119 {
 120   /* No relocation.  */
 121   HOWTO (R_SH_NONE,             /* type */
 122          0,                     /* rightshift */
 123          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 124          0,                     /* bitsize */
 125          false,                 /* pc_relative */
 126          0,                     /* bitpos */
 127          complain_overflow_dont, /* complain_on_overflow */
 128          sh_elf_ignore_reloc,   /* special_function */
 129          "R_SH_NONE",           /* name */
 130          false,                 /* partial_inplace */
 131          0,                     /* src_mask */
 132          0,                     /* dst_mask */
 133          false),                /* pcrel_offset */
 134
 135   /* 32 bit absolute relocation.  Setting partial_inplace to true and
 136      src_mask to a non-zero value is similar to the COFF toolchain.  */
 137   HOWTO (R_SH_DIR32,            /* type */
 138          0,                     /* rightshift */
 139          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 140          32,                    /* bitsize */
 141          false,                 /* pc_relative */
 142          0,                     /* bitpos */
 143          complain_overflow_bitfield, /* complain_on_overflow */
 144          sh_elf_reloc,          /* special_function */
 145          "R_SH_DIR32",          /* name */
 146          true,                  /* partial_inplace */
 147          0xffffffff,            /* src_mask */
 148          0xffffffff,            /* dst_mask */
 149          false),                /* pcrel_offset */
 150
 151   /* 32 bit PC relative relocation.  */
 152   HOWTO (R_SH_REL32,            /* type */
 153          0,                     /* rightshift */
 154          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 155          32,                    /* bitsize */
 156          true,                  /* pc_relative */
 157          0,                     /* bitpos */
 158          complain_overflow_signed, /* complain_on_overflow */
 159          sh_elf_ignore_reloc,   /* special_function */
 160          "R_SH_REL32",          /* name */
 161          true,                  /* partial_inplace */
 162          0xffffffff,            /* src_mask */
 163          0xffffffff,            /* dst_mask */
 164          true),                 /* pcrel_offset */
 165
 166   /* 8 bit PC relative branch divided by 2.  */
 167   HOWTO (R_SH_DIR8WPN,          /* type */
 168          1,                     /* rightshift */
 169          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 170          8,                     /* bitsize */
 171          true,                  /* pc_relative */
 172          0,                     /* bitpos */
 173          complain_overflow_signed, /* complain_on_overflow */
 174          sh_elf_ignore_reloc,   /* special_function */
 175          "R_SH_DIR8WPN",        /* name */
 176          true,                  /* partial_inplace */
 177          0xff,                  /* src_mask */
 178          0xff,                  /* dst_mask */
 179          true),                 /* pcrel_offset */
 180
 181   /* 12 bit PC relative branch divided by 2.  */
 182   HOWTO (R_SH_IND12W,           /* type */
 183          1,                     /* rightshift */
 184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 185          12,                    /* bitsize */
 186          true,                  /* pc_relative */
 187          0,                     /* bitpos */
 188          complain_overflow_signed, /* complain_on_overflow */
 189          sh_elf_reloc,          /* special_function */
 190          "R_SH_IND12W",         /* name */
 191          true,                  /* partial_inplace */
 192          0xfff,                 /* src_mask */
 193          0xfff,                 /* dst_mask */
 194          true),                 /* pcrel_offset */
 195
 196   /* 8 bit unsigned PC relative divided by 4.  */
 197   HOWTO (R_SH_DIR8WPL,          /* type */
 198          2,                     /* rightshift */
 199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 200          8,                     /* bitsize */
 201          true,                  /* pc_relative */
 202          0,                     /* bitpos */
 203          complain_overflow_unsigned, /* complain_on_overflow */
 204          sh_elf_ignore_reloc,   /* special_function */
 205          "R_SH_DIR8WPL",        /* name */
 206          true,                  /* partial_inplace */
 207          0xff,                  /* src_mask */
 208          0xff,                  /* dst_mask */
 209          true),                 /* pcrel_offset */
 210
 211   /* 8 bit unsigned PC relative divided by 2.  */
 212   HOWTO (R_SH_DIR8WPZ,          /* type */
 213          1,                     /* rightshift */
 214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          8,                     /* bitsize */
 216          true,                  /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_unsigned, /* complain_on_overflow */
 219          sh_elf_ignore_reloc,   /* special_function */
 220          "R_SH_DIR8WPZ",        /* name */
 221          true,                  /* partial_inplace */
 222          0xff,                  /* src_mask */
 223          0xff,                  /* dst_mask */
 224          true),                 /* pcrel_offset */
 225
 226   /* 8 bit GBR relative.  FIXME: This only makes sense if we have some
 227      special symbol for the GBR relative area, and that is not
 228      implemented.  */
 229   HOWTO (R_SH_DIR8BP,           /* type */
 230          0,                     /* rightshift */
 231          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 232          8,                     /* bitsize */
 233          false,                 /* pc_relative */
 234          0,                     /* bitpos */
 235          complain_overflow_unsigned, /* complain_on_overflow */
 236          sh_elf_ignore_reloc,   /* special_function */
 237          "R_SH_DIR8BP",         /* name */
 238          false,                 /* partial_inplace */
 239          0,                     /* src_mask */
 240          0xff,                  /* dst_mask */
 241          true),                 /* pcrel_offset */
 242
 243   /* 8 bit GBR relative divided by 2.  FIXME: This only makes sense if
 244      we have some special symbol for the GBR relative area, and that
 245      is not implemented.  */
 246   HOWTO (R_SH_DIR8W,            /* type */
 247          1,                     /* rightshift */
 248          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 249          8,                     /* bitsize */
 250          false,                 /* pc_relative */
 251          0,                     /* bitpos */
 252          complain_overflow_unsigned, /* complain_on_overflow */
 253          sh_elf_ignore_reloc,   /* special_function */
 254          "R_SH_DIR8W",          /* name */
 255          false,                 /* partial_inplace */
 256          0,                     /* src_mask */
 257          0xff,                  /* dst_mask */
 258          true),                 /* pcrel_offset */
 259
 260   /* 8 bit GBR relative divided by 4.  FIXME: This only makes sense if
 261      we have some special symbol for the GBR relative area, and that
 262      is not implemented.  */
 263   HOWTO (R_SH_DIR8L,            /* type */
 264          2,                     /* rightshift */
 265          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 266          8,                     /* bitsize */
 267          false,                 /* pc_relative */
 268          0,                     /* bitpos */
 269          complain_overflow_unsigned, /* complain_on_overflow */
 270          sh_elf_ignore_reloc,   /* special_function */
 271          "R_SH_DIR8L",          /* name */
 272          false,                 /* partial_inplace */
 273          0,                     /* src_mask */
 274          0xff,                  /* dst_mask */
 275          true),                 /* pcrel_offset */
 276
 277   EMPTY_HOWTO (10),
 278   EMPTY_HOWTO (11),
 279   EMPTY_HOWTO (12),
 280   EMPTY_HOWTO (13),
 281   EMPTY_HOWTO (14),
 282   EMPTY_HOWTO (15),
 283   EMPTY_HOWTO (16),
 284   EMPTY_HOWTO (17),
 285   EMPTY_HOWTO (18),
 286   EMPTY_HOWTO (19),
 287   EMPTY_HOWTO (20),
 288   EMPTY_HOWTO (21),
 289   EMPTY_HOWTO (22),
 290   EMPTY_HOWTO (23),
 291   EMPTY_HOWTO (24),
 292
 293   /* The remaining relocs are a GNU extension used for relaxing.  The
 294      final pass of the linker never needs to do anything with any of
 295      these relocs.  Any required operations are handled by the
 296      relaxation code.  */
 297
 298   /* A 16 bit switch table entry.  This is generated for an expression
 299      such as ``.word L1 - L2''.  The offset holds the difference
 300      between the reloc address and L2.  */
 301   HOWTO (R_SH_SWITCH16,         /* type */
 302          0,                     /* rightshift */
 303          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 304          16,                    /* bitsize */
 305          false,                 /* pc_relative */
 306          0,                     /* bitpos */
 307          complain_overflow_unsigned, /* complain_on_overflow */
 308          sh_elf_ignore_reloc,   /* special_function */
 309          "R_SH_SWITCH16",       /* name */
 310          false,                 /* partial_inplace */
 311          0,                     /* src_mask */
 312          0,                     /* dst_mask */
 313          true),                 /* pcrel_offset */
 314
 315   /* A 32 bit switch table entry.  This is generated for an expression
 316      such as ``.long L1 - L2''.  The offset holds the difference
 317      between the reloc address and L2.  */
 318   HOWTO (R_SH_SWITCH32,         /* type */
 319          0,                     /* rightshift */
 320          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 321          32,                    /* bitsize */
 322          false,                 /* pc_relative */
 323          0,                     /* bitpos */
 324          complain_overflow_unsigned, /* complain_on_overflow */
 325          sh_elf_ignore_reloc,   /* special_function */
 326          "R_SH_SWITCH32",       /* name */
 327          false,                 /* partial_inplace */
 328          0,                     /* src_mask */
 329          0,                     /* dst_mask */
 330          true),                 /* pcrel_offset */
 331
 332   /* Indicates a .uses pseudo-op.  The compiler will generate .uses
 333      pseudo-ops when it finds a function call which can be relaxed.
 334      The offset field holds the PC relative offset to the instruction
 335      which loads the register used in the function call.  */
 336   HOWTO (R_SH_USES,             /* type */
 337          0,                     /* rightshift */
 338          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 339          0,                     /* bitsize */
 340          false,                 /* pc_relative */
 341          0,                     /* bitpos */
 342          complain_overflow_unsigned, /* complain_on_overflow */
 343          sh_elf_ignore_reloc,   /* special_function */
 344          "R_SH_USES",           /* name */
 345          false,                 /* partial_inplace */
 346          0,                     /* src_mask */
 347          0,                     /* dst_mask */
 348          true),                 /* pcrel_offset */
 349
 350   /* The assembler will generate this reloc for addresses referred to
 351      by the register loads associated with USES relocs.  The offset
 352      field holds the number of times the address is referenced in the
 353      object file.  */
 354   HOWTO (R_SH_COUNT,            /* type */
 355          0,                     /* rightshift */
 356          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          0,                     /* bitsize */
 358          false,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_unsigned, /* complain_on_overflow */
 361          sh_elf_ignore_reloc,   /* special_function */
 362          "R_SH_COUNT",          /* name */
 363          false,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0,                     /* dst_mask */
 366          true),                 /* pcrel_offset */
 367
 368   /* Indicates an alignment statement.  The offset field is the power
 369      of 2 to which subsequent portions of the object file must be
 370      aligned.  */
 371   HOWTO (R_SH_ALIGN,            /* type */
 372          0,                     /* rightshift */
 373          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 374          0,                     /* bitsize */
 375          false,                 /* pc_relative */
 376          0,                     /* bitpos */
 377          complain_overflow_unsigned, /* complain_on_overflow */
 378          sh_elf_ignore_reloc,   /* special_function */
 379          "R_SH_ALIGN",  /* name */
 380          false,                 /* partial_inplace */
 381          0,                     /* src_mask */
 382          0,                     /* dst_mask */
 383          true),                 /* pcrel_offset */
 384
 385   /* The assembler will generate this reloc before a block of
 386      instructions.  A section should be processed as assumining it
 387      contains data, unless this reloc is seen.  */
 388   HOWTO (R_SH_CODE,             /* type */
 389          0,                     /* rightshift */
 390          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 391          0,                     /* bitsize */
 392          false,                 /* pc_relative */
 393          0,                     /* bitpos */
 394          complain_overflow_unsigned, /* complain_on_overflow */
 395          sh_elf_ignore_reloc,   /* special_function */
 396          "R_SH_CODE",           /* name */
 397          false,                 /* partial_inplace */
 398          0,                     /* src_mask */
 399          0,                     /* dst_mask */
 400          true),                 /* pcrel_offset */
 401
 402   /* The assembler will generate this reloc after a block of
 403      instructions when it sees data that is not instructions.  */
 404   HOWTO (R_SH_DATA,             /* type */
 405          0,                     /* rightshift */
 406          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 407          0,                     /* bitsize */
 408          false,                 /* pc_relative */
 409          0,                     /* bitpos */
 410          complain_overflow_unsigned, /* complain_on_overflow */
 411          sh_elf_ignore_reloc,   /* special_function */
 412          "R_SH_DATA",           /* name */
 413          false,                 /* partial_inplace */
 414          0,                     /* src_mask */
 415          0,                     /* dst_mask */
 416          true),                 /* pcrel_offset */
 417
 418   /* The assembler generates this reloc for each label within a block
 419      of instructions.  This permits the linker to avoid swapping
 420      instructions which are the targets of branches.  */
 421   HOWTO (R_SH_LABEL,            /* type */
 422          0,                     /* rightshift */
 423          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 424          0,                     /* bitsize */
 425          false,                 /* pc_relative */
 426          0,                     /* bitpos */
 427          complain_overflow_unsigned, /* complain_on_overflow */
 428          sh_elf_ignore_reloc,   /* special_function */
 429          "R_SH_LABEL",          /* name */
 430          false,                 /* partial_inplace */
 431          0,                     /* src_mask */
 432          0,                     /* dst_mask */
 433          true),                 /* pcrel_offset */
 434
 435   /* An 8 bit switch table entry.  This is generated for an expression
 436      such as ``.word L1 - L2''.  The offset holds the difference
 437      between the reloc address and L2.  */
 438   HOWTO (R_SH_SWITCH8,          /* type */
 439          0,                     /* rightshift */
 440          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 441          8,                     /* bitsize */
 442          false,                 /* pc_relative */
 443          0,                     /* bitpos */
 444          complain_overflow_unsigned, /* complain_on_overflow */
 445          sh_elf_ignore_reloc,   /* special_function */
 446          "R_SH_SWITCH8",        /* name */
 447          false,                 /* partial_inplace */
 448          0,                     /* src_mask */
 449          0,                     /* dst_mask */
 450          true),                 /* pcrel_offset */
 451
 452   /* GNU extension to record C++ vtable hierarchy */
 453   HOWTO (R_SH_GNU_VTINHERIT, /* type */
 454          0,                     /* rightshift */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          0,                     /* bitsize */
 457          false,                 /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_dont, /* complain_on_overflow */
 460          NULL,                  /* special_function */
 461          "R_SH_GNU_VTINHERIT", /* name */
 462          false,                 /* partial_inplace */
 463          0,                     /* src_mask */
 464          0,                     /* dst_mask */
 465          false),                /* pcrel_offset */
 466
 467   /* GNU extension to record C++ vtable member usage */
 468   HOWTO (R_SH_GNU_VTENTRY,     /* type */
 469          0,                     /* rightshift */
 470          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          0,                     /* bitsize */
 472          false,                 /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_dont, /* complain_on_overflow */
 475          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 476          "R_SH_GNU_VTENTRY",   /* name */
 477          false,                 /* partial_inplace */
 478          0,                     /* src_mask */
 479          0,                     /* dst_mask */
 480          false),                /* pcrel_offset */
 481
 482   /* 8 bit PC relative divided by 2 - but specified in a very odd way.  */
 483   HOWTO (R_SH_LOOP_START,       /* type */
 484          1,                     /* rightshift */
 485          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 486          8,                     /* bitsize */
 487          false,                 /* pc_relative */
 488          0,                     /* bitpos */
 489          complain_overflow_signed, /* complain_on_overflow */
 490          sh_elf_ignore_reloc,   /* special_function */
 491          "R_SH_LOOP_START",     /* name */
 492          true,                  /* partial_inplace */
 493          0xff,                  /* src_mask */
 494          0xff,                  /* dst_mask */
 495          true),                 /* pcrel_offset */
 496
 497   /* 8 bit PC relative divided by 2 - but specified in a very odd way.  */
 498   HOWTO (R_SH_LOOP_END,         /* type */
 499          1,                     /* rightshift */
 500          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 501          8,                     /* bitsize */
 502          false,                 /* pc_relative */
 503          0,                     /* bitpos */
 504          complain_overflow_signed, /* complain_on_overflow */
 505          sh_elf_ignore_reloc,   /* special_function */
 506          "R_SH_LOOP_END",       /* name */
 507          true,                  /* partial_inplace */
 508          0xff,                  /* src_mask */
 509          0xff,                  /* dst_mask */
 510          true),                 /* pcrel_offset */
 511
 512   EMPTY_HOWTO (38),
 513   EMPTY_HOWTO (39),
 514   EMPTY_HOWTO (40),
 515   EMPTY_HOWTO (41),
 516   EMPTY_HOWTO (42),
 517   EMPTY_HOWTO (43),
 518   EMPTY_HOWTO (44),
 519
 520 #ifdef INCLUDE_SHMEDIA
 521   /* Used in SHLLI.L and SHLRI.L.  */
 522   HOWTO (R_SH_DIR5U,            /* type */
 523          0,                     /* rightshift */
 524          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 525          5,                     /* bitsize */
 526          false,                 /* pc_relative */
 527          10,                    /* bitpos */
 528          complain_overflow_unsigned, /* complain_on_overflow */
 529          bfd_elf_generic_reloc, /* special_function */
 530          "R_SH_DIR5U",          /* name */
 531          false,                 /* partial_inplace */
 532          0,                     /* src_mask */
 533          0xfc00,                /* dst_mask */
 534          false),                /* pcrel_offset */
 535
 536   /* Used in SHARI, SHLLI et al.  */
 537   HOWTO (R_SH_DIR6U,            /* type */
 538          0,                     /* rightshift */
 539          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 540          6,                     /* bitsize */
 541          false,                 /* pc_relative */
 542          10,                    /* bitpos */
 543          complain_overflow_unsigned, /* complain_on_overflow */
 544          bfd_elf_generic_reloc, /* special_function */
 545          "R_SH_DIR6U",          /* name */
 546          false,                 /* partial_inplace */
 547          0,                     /* src_mask */
 548          0xfc00,                /* dst_mask */
 549          false),                /* pcrel_offset */
 550
 551   /* Used in BxxI, LDHI.L et al.  */
 552   HOWTO (R_SH_DIR6S,            /* type */
 553          0,                     /* rightshift */
 554          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 555          6,                     /* bitsize */
 556          false,                 /* pc_relative */
 557          10,                    /* bitpos */
 558          complain_overflow_signed, /* complain_on_overflow */
 559          bfd_elf_generic_reloc, /* special_function */
 560          "R_SH_DIR6S",          /* name */
 561          false,                 /* partial_inplace */
 562          0,                     /* src_mask */
 563          0xfc00,                /* dst_mask */
 564          false),                /* pcrel_offset */
 565
 566   /* Used in ADDI, ANDI et al.  */
 567   HOWTO (R_SH_DIR10S,           /* type */
 568          0,                     /* rightshift */
 569          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 570          10,                    /* bitsize */
 571          false,                 /* pc_relative */
 572          10,                    /* bitpos */
 573          complain_overflow_signed, /* complain_on_overflow */
 574          bfd_elf_generic_reloc, /* special_function */
 575          "R_SH_DIR10S",         /* name */
 576          false,                 /* partial_inplace */
 577          0,                     /* src_mask */
 578          0xffc00,               /* dst_mask */
 579          false),                /* pcrel_offset */
 580
 581   /* Used in LD.UW, ST.W et al.  */
 582   HOWTO (R_SH_DIR10SW,  /* type */
 583          1,                     /* rightshift */
 584          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 585          11,                    /* bitsize */
 586          false,                 /* pc_relative */
 587          10,                    /* bitpos */
 588          complain_overflow_signed, /* complain_on_overflow */
 589          bfd_elf_generic_reloc, /* special_function */
 590          "R_SH_DIR10SW",        /* name */
 591          false,                 /* partial_inplace */
 592          0,                     /* src_mask */
 593          0xffc00,               /* dst_mask */
 594          false),                /* pcrel_offset */
 595
 596   /* Used in LD.L, FLD.S et al.  */
 597   HOWTO (R_SH_DIR10SL,  /* type */
 598          2,                     /* rightshift */
 599          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 600          12,                    /* bitsize */
 601          false,                 /* pc_relative */
 602          10,                    /* bitpos */
 603          complain_overflow_signed, /* complain_on_overflow */
 604          bfd_elf_generic_reloc, /* special_function */
 605          "R_SH_DIR10SL",        /* name */
 606          false,                 /* partial_inplace */
 607          0,                     /* src_mask */
 608          0xffc00,               /* dst_mask */
 609          false),                /* pcrel_offset */
 610
 611   /* Used in FLD.D, FST.P et al.  */
 612   HOWTO (R_SH_DIR10SQ,  /* type */
 613          3,                     /* rightshift */
 614          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 615          13,                    /* bitsize */
 616          false,                 /* pc_relative */
 617          10,                    /* bitpos */
 618          complain_overflow_signed, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_SH_DIR10SQ",        /* name */
 621          false,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          0xffc00,               /* dst_mask */
 624          false),                /* pcrel_offset */
 625
 626 #else
 627   EMPTY_HOWTO (45),
 628   EMPTY_HOWTO (46),
 629   EMPTY_HOWTO (47),
 630   EMPTY_HOWTO (48),
 631   EMPTY_HOWTO (49),
 632   EMPTY_HOWTO (50),
 633   EMPTY_HOWTO (51),
 634 #endif
 635
 636   EMPTY_HOWTO (52),
 637   EMPTY_HOWTO (53),
 638   EMPTY_HOWTO (54),
 639   EMPTY_HOWTO (55),
 640   EMPTY_HOWTO (56),
 641   EMPTY_HOWTO (57),
 642   EMPTY_HOWTO (58),
 643   EMPTY_HOWTO (59),
 644   EMPTY_HOWTO (60),
 645   EMPTY_HOWTO (61),
 646   EMPTY_HOWTO (62),
 647   EMPTY_HOWTO (63),
 648   EMPTY_HOWTO (64),
 649   EMPTY_HOWTO (65),
 650   EMPTY_HOWTO (66),
 651   EMPTY_HOWTO (67),
 652   EMPTY_HOWTO (68),
 653   EMPTY_HOWTO (69),
 654   EMPTY_HOWTO (70),
 655   EMPTY_HOWTO (71),
 656   EMPTY_HOWTO (72),
 657   EMPTY_HOWTO (73),
 658   EMPTY_HOWTO (74),
 659   EMPTY_HOWTO (75),
 660   EMPTY_HOWTO (76),
 661   EMPTY_HOWTO (77),
 662   EMPTY_HOWTO (78),
 663   EMPTY_HOWTO (79),
 664   EMPTY_HOWTO (80),
 665   EMPTY_HOWTO (81),
 666   EMPTY_HOWTO (82),
 667   EMPTY_HOWTO (83),
 668   EMPTY_HOWTO (84),
 669   EMPTY_HOWTO (85),
 670   EMPTY_HOWTO (86),
 671   EMPTY_HOWTO (87),
 672   EMPTY_HOWTO (88),
 673   EMPTY_HOWTO (89),
 674   EMPTY_HOWTO (90),
 675   EMPTY_HOWTO (91),
 676   EMPTY_HOWTO (92),
 677   EMPTY_HOWTO (93),
 678   EMPTY_HOWTO (94),
 679   EMPTY_HOWTO (95),
 680   EMPTY_HOWTO (96),
 681   EMPTY_HOWTO (97),
 682   EMPTY_HOWTO (98),
 683   EMPTY_HOWTO (99),
 684   EMPTY_HOWTO (100),
 685   EMPTY_HOWTO (101),
 686   EMPTY_HOWTO (102),
 687   EMPTY_HOWTO (103),
 688   EMPTY_HOWTO (104),
 689   EMPTY_HOWTO (105),
 690   EMPTY_HOWTO (106),
 691   EMPTY_HOWTO (107),
 692   EMPTY_HOWTO (108),
 693   EMPTY_HOWTO (109),
 694   EMPTY_HOWTO (110),
 695   EMPTY_HOWTO (111),
 696   EMPTY_HOWTO (112),
 697   EMPTY_HOWTO (113),
 698   EMPTY_HOWTO (114),
 699   EMPTY_HOWTO (115),
 700   EMPTY_HOWTO (116),
 701   EMPTY_HOWTO (117),
 702   EMPTY_HOWTO (118),
 703   EMPTY_HOWTO (119),
 704   EMPTY_HOWTO (120),
 705   EMPTY_HOWTO (121),
 706   EMPTY_HOWTO (122),
 707   EMPTY_HOWTO (123),
 708   EMPTY_HOWTO (124),
 709   EMPTY_HOWTO (125),
 710   EMPTY_HOWTO (126),
 711   EMPTY_HOWTO (127),
 712   EMPTY_HOWTO (128),
 713   EMPTY_HOWTO (129),
 714   EMPTY_HOWTO (130),
 715   EMPTY_HOWTO (131),
 716   EMPTY_HOWTO (132),
 717   EMPTY_HOWTO (133),
 718   EMPTY_HOWTO (134),
 719   EMPTY_HOWTO (135),
 720   EMPTY_HOWTO (136),
 721   EMPTY_HOWTO (137),
 722   EMPTY_HOWTO (138),
 723   EMPTY_HOWTO (139),
 724   EMPTY_HOWTO (140),
 725   EMPTY_HOWTO (141),
 726   EMPTY_HOWTO (142),
 727   EMPTY_HOWTO (143),
 728
 729   HOWTO (R_SH_TLS_GD_32,        /* type */
 730          0,                     /* rightshift */
 731          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 732          32,                    /* bitsize */
 733          false,                 /* pc_relative */
 734          0,                     /* bitpos */
 735          complain_overflow_bitfield, /* complain_on_overflow */
 736          bfd_elf_generic_reloc, /* */
 737          "R_SH_TLS_GD_32",      /* name */
 738          true,                  /* partial_inplace */
 739          0xffffffff,            /* src_mask */
 740          0xffffffff,            /* dst_mask */
 741          false),                /* pcrel_offset */
 742
 743   HOWTO (R_SH_TLS_LD_32,        /* type */
 744          0,                     /* rightshift */
 745          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 746          32,                    /* bitsize */
 747          false,                 /* pc_relative */
 748          0,                     /* bitpos */
 749          complain_overflow_bitfield, /* complain_on_overflow */
 750          bfd_elf_generic_reloc, /* */
 751          "R_SH_TLS_LD_32",      /* name */
 752          true,                  /* partial_inplace */
 753          0xffffffff,            /* src_mask */
 754          0xffffffff,            /* dst_mask */
 755          false),                /* pcrel_offset */
 756
 757   HOWTO (R_SH_TLS_LDO_32,       /* type */
 758          0,                     /* rightshift */
 759          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          32,                    /* bitsize */
 761          false,                 /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_bitfield, /* complain_on_overflow */
 764          bfd_elf_generic_reloc, /* */
 765          "R_SH_TLS_LDO_32",     /* name */
 766          true,                  /* partial_inplace */
 767          0xffffffff,            /* src_mask */
 768          0xffffffff,            /* dst_mask */
 769          false),                /* pcrel_offset */
 770
 771   HOWTO (R_SH_TLS_IE_32,        /* type */
 772          0,                     /* rightshift */
 773          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 774          32,                    /* bitsize */
 775          false,                 /* pc_relative */
 776          0,                     /* bitpos */
 777          complain_overflow_bitfield, /* complain_on_overflow */
 778          bfd_elf_generic_reloc, /* */
 779          "R_SH_TLS_IE_32",      /* name */
 780          true,                  /* partial_inplace */
 781          0xffffffff,            /* src_mask */
 782          0xffffffff,            /* dst_mask */
 783          false),                /* pcrel_offset */
 784
 785   HOWTO (R_SH_TLS_LE_32,        /* type */
 786          0,                     /* rightshift */
 787          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          32,                    /* bitsize */
 789          false,                 /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_bitfield, /* complain_on_overflow */
 792          bfd_elf_generic_reloc, /* */
 793          "R_SH_TLS_LE_32",      /* name */
 794          true,                  /* partial_inplace */
 795          0xffffffff,            /* src_mask */
 796          0xffffffff,            /* dst_mask */
 797          false),                /* pcrel_offset */
 798
 799   HOWTO (R_SH_TLS_DTPMOD32,     /* type */
 800          0,                     /* rightshift */
 801          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 802          32,                    /* bitsize */
 803          false,                 /* pc_relative */
 804          0,                     /* bitpos */
 805          complain_overflow_bitfield, /* complain_on_overflow */
 806          bfd_elf_generic_reloc, /* */
 807          "R_SH_TLS_DTPMOD32",   /* name */
 808          true,                  /* partial_inplace */
 809          0xffffffff,            /* src_mask */
 810          0xffffffff,            /* dst_mask */
 811          false),                /* pcrel_offset */
 812
 813   HOWTO (R_SH_TLS_DTPOFF32,     /* type */
 814          0,                     /* rightshift */
 815          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 816          32,                    /* bitsize */
 817          false,                 /* pc_relative */
 818          0,                     /* bitpos */
 819          complain_overflow_bitfield, /* complain_on_overflow */
 820          bfd_elf_generic_reloc, /* */
 821          "R_SH_TLS_DTPOFF32",   /* name */
 822          true,                  /* partial_inplace */
 823          0xffffffff,            /* src_mask */
 824          0xffffffff,            /* dst_mask */
 825          false),                /* pcrel_offset */
 826
 827   HOWTO (R_SH_TLS_TPOFF32,      /* type */
 828          0,                     /* rightshift */
 829          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 830          32,                    /* bitsize */
 831          false,                 /* pc_relative */
 832          0,                     /* bitpos */
 833          complain_overflow_bitfield, /* complain_on_overflow */
 834          bfd_elf_generic_reloc, /* */
 835          "R_SH_TLS_TPOFF32",    /* name */
 836          true,                  /* partial_inplace */
 837          0xffffffff,            /* src_mask */
 838          0xffffffff,            /* dst_mask */
 839          false),                /* pcrel_offset */
 840
 841   EMPTY_HOWTO (152),
 842   EMPTY_HOWTO (153),
 843   EMPTY_HOWTO (154),
 844   EMPTY_HOWTO (155),
 845   EMPTY_HOWTO (156),
 846   EMPTY_HOWTO (157),
 847   EMPTY_HOWTO (158),
 848   EMPTY_HOWTO (159),
 849
 850   HOWTO (R_SH_GOT32,            /* type */
 851          0,                     /* rightshift */
 852          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 853          32,                    /* bitsize */
 854          false,                 /* pc_relative */
 855          0,                     /* bitpos */
 856          complain_overflow_bitfield, /* complain_on_overflow */
 857          bfd_elf_generic_reloc, /* */
 858          "R_SH_GOT32",          /* name */
 859          true,                  /* partial_inplace */
 860          0xffffffff,            /* src_mask */
 861          0xffffffff,            /* dst_mask */
 862          false),                /* pcrel_offset */
 863
 864   HOWTO (R_SH_PLT32,            /* type */
 865          0,                     /* rightshift */
 866          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 867          32,                    /* bitsize */
 868          true,                  /* pc_relative */
 869          0,                     /* bitpos */
 870          complain_overflow_bitfield, /* complain_on_overflow */
 871          bfd_elf_generic_reloc, /* */
 872          "R_SH_PLT32",          /* name */
 873          true,                  /* partial_inplace */
 874          0xffffffff,            /* src_mask */
 875          0xffffffff,            /* dst_mask */
 876          true),                 /* pcrel_offset */
 877
 878   HOWTO (R_SH_COPY,             /* type */
 879          0,                     /* rightshift */
 880          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 881          32,                    /* bitsize */
 882          false,                 /* pc_relative */
 883          0,                     /* bitpos */
 884          complain_overflow_bitfield, /* complain_on_overflow */
 885          bfd_elf_generic_reloc, /* */
 886          "R_SH_COPY",           /* name */
 887          true,                  /* partial_inplace */
 888          0xffffffff,            /* src_mask */
 889          0xffffffff,            /* dst_mask */
 890          false),                /* pcrel_offset */
 891
 892   HOWTO (R_SH_GLOB_DAT,         /* type */
 893          0,                     /* rightshift */
 894          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 895          32,                    /* bitsize */
 896          false,                 /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_bitfield, /* complain_on_overflow */
 899          bfd_elf_generic_reloc, /* */
 900          "R_SH_GLOB_DAT",       /* name */
 901          true,                  /* partial_inplace */
 902          0xffffffff,            /* src_mask */
 903          0xffffffff,            /* dst_mask */
 904          false),                /* pcrel_offset */
 905
 906   HOWTO (R_SH_JMP_SLOT,         /* type */
 907          0,                     /* rightshift */
 908          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 909          32,                    /* bitsize */
 910          false,                 /* pc_relative */
 911          0,                     /* bitpos */
 912          complain_overflow_bitfield, /* complain_on_overflow */
 913          bfd_elf_generic_reloc, /* */
 914          "R_SH_JMP_SLOT",       /* name */
 915          true,                  /* partial_inplace */
 916          0xffffffff,            /* src_mask */
 917          0xffffffff,            /* dst_mask */
 918          false),                /* pcrel_offset */
 919
 920   HOWTO (R_SH_RELATIVE,         /* type */
 921          0,                     /* rightshift */
 922          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 923          32,                    /* bitsize */
 924          false,                 /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_bitfield, /* complain_on_overflow */
 927          bfd_elf_generic_reloc, /* */
 928          "R_SH_RELATIVE",       /* name */
 929          true,                  /* partial_inplace */
 930          0xffffffff,            /* src_mask */
 931          0xffffffff,            /* dst_mask */
 932          false),                /* pcrel_offset */
 933
 934   HOWTO (R_SH_GOTOFF,           /* type */
 935          0,                     /* rightshift */
 936          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 937          32,                    /* bitsize */
 938          false,                 /* pc_relative */
 939          0,                     /* bitpos */
 940          complain_overflow_bitfield, /* complain_on_overflow */
 941          bfd_elf_generic_reloc, /* */
 942          "R_SH_GOTOFF",         /* name */
 943          true,                  /* partial_inplace */
 944          0xffffffff,            /* src_mask */
 945          0xffffffff,            /* dst_mask */
 946          false),                /* pcrel_offset */
 947
 948   HOWTO (R_SH_GOTPC,            /* type */
 949          0,                     /* rightshift */
 950          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 951          32,                    /* bitsize */
 952          true,                  /* pc_relative */
 953          0,                     /* bitpos */
 954          complain_overflow_bitfield, /* complain_on_overflow */
 955          bfd_elf_generic_reloc, /* */
 956          "R_SH_GOTPC",          /* name */
 957          true,                  /* partial_inplace */
 958          0xffffffff,            /* src_mask */
 959          0xffffffff,            /* dst_mask */
 960          true),                 /* pcrel_offset */
 961
 962   HOWTO (R_SH_GOTPLT32,         /* type */
 963          0,                     /* rightshift */
 964          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 965          32,                    /* bitsize */
 966          false,                 /* pc_relative */
 967          0,                     /* bitpos */
 968          complain_overflow_bitfield, /* complain_on_overflow */
 969          bfd_elf_generic_reloc, /* */
 970          "R_SH_GOTPLT32",       /* name */
 971          false,                 /* partial_inplace */
 972          0xffffffff,            /* src_mask */
 973          0xffffffff,            /* dst_mask */
 974          false),                /* pcrel_offset */
 975
 976 #ifdef INCLUDE_SHMEDIA
 977   /* Used in MOVI and SHORI (x & 65536).  */
 978   HOWTO (R_SH_GOT_LOW16,        /* type */
 979          0,                     /* rightshift */
 980          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 981          64,                    /* bitsize */
 982          false,                 /* pc_relative */
 983          10,                    /* bitpos */
 984          complain_overflow_dont, /* complain_on_overflow */
 985          bfd_elf_generic_reloc, /* special_function */
 986          "R_SH_GOT_LOW16",      /* name */
 987          false,                 /* partial_inplace */
 988          0,                     /* src_mask */
 989          0x3fffc00,             /* dst_mask */
 990          false),                /* pcrel_offset */
 991
 992   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
 993   HOWTO (R_SH_GOT_MEDLOW16,     /* type */
 994          16,                    /* rightshift */
 995          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 996          64,                    /* bitsize */
 997          false,                 /* pc_relative */
 998          10,                    /* bitpos */
 999          complain_overflow_dont, /* complain_on_overflow */
1000          bfd_elf_generic_reloc, /* special_function */
1001          "R_SH_GOT_MEDLOW16",   /* name */
1002          false,                 /* partial_inplace */
1003          0,                     /* src_mask */
1004          0x3fffc00,             /* dst_mask */
1005          false),                /* pcrel_offset */
1006
1007   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1008   HOWTO (R_SH_GOT_MEDHI16,      /* type */
1009          32,                    /* rightshift */
1010          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1011          64,                    /* bitsize */
1012          false,                 /* pc_relative */
1013          10,                    /* bitpos */
1014          complain_overflow_dont, /* complain_on_overflow */
1015          bfd_elf_generic_reloc, /* special_function */
1016          "R_SH_GOT_MEDHI16",    /* name */
1017          false,                 /* partial_inplace */
1018          0,                     /* src_mask */
1019          0x3fffc00,             /* dst_mask */
1020          false),                /* pcrel_offset */
1021
1022   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1023   HOWTO (R_SH_GOT_HI16,         /* type */
1024          48,                    /* rightshift */
1025          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1026          64,                    /* bitsize */
1027          false,                 /* pc_relative */
1028          10,                    /* bitpos */
1029          complain_overflow_dont, /* complain_on_overflow */
1030          bfd_elf_generic_reloc, /* special_function */
1031          "R_SH_GOT_HI16",       /* name */
1032          false,                 /* partial_inplace */
1033          0,                     /* src_mask */
1034          0x3fffc00,             /* dst_mask */
1035          false),                /* pcrel_offset */
1036
1037   /* Used in MOVI and SHORI (x & 65536).  */
1038   HOWTO (R_SH_GOTPLT_LOW16,     /* type */
1039          0,                     /* rightshift */
1040          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1041          64,                    /* bitsize */
1042          false,                 /* pc_relative */
1043          10,                    /* bitpos */
1044          complain_overflow_dont, /* complain_on_overflow */
1045          bfd_elf_generic_reloc, /* special_function */
1046          "R_SH_GOTPLT_LOW16",   /* name */
1047          false,                 /* partial_inplace */
1048          0,                     /* src_mask */
1049          0x3fffc00,             /* dst_mask */
1050          false),                /* pcrel_offset */
1051
1052   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
1053   HOWTO (R_SH_GOTPLT_MEDLOW16,  /* type */
1054          16,                    /* rightshift */
1055          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1056          64,                    /* bitsize */
1057          false,                 /* pc_relative */
1058          10,                    /* bitpos */
1059          complain_overflow_dont, /* complain_on_overflow */
1060          bfd_elf_generic_reloc, /* special_function */
1061          "R_SH_GOTPLT_MEDLOW16", /* name */
1062          false,                 /* partial_inplace */
1063          0,                     /* src_mask */
1064          0x3fffc00,             /* dst_mask */
1065          false),                /* pcrel_offset */
1066
1067   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1068   HOWTO (R_SH_GOTPLT_MEDHI16,   /* type */
1069          32,                    /* rightshift */
1070          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1071          64,                    /* bitsize */
1072          false,                 /* pc_relative */
1073          10,                    /* bitpos */
1074          complain_overflow_dont, /* complain_on_overflow */
1075          bfd_elf_generic_reloc, /* special_function */
1076          "R_SH_GOTPLT_MEDHI16", /* name */
1077          false,                 /* partial_inplace */
1078          0,                     /* src_mask */
1079          0x3fffc00,             /* dst_mask */
1080          false),                /* pcrel_offset */
1081
1082   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1083   HOWTO (R_SH_GOTPLT_HI16,      /* type */
1084          48,                    /* rightshift */
1085          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1086          64,                    /* bitsize */
1087          false,                 /* pc_relative */
1088          10,                    /* bitpos */
1089          complain_overflow_dont, /* complain_on_overflow */
1090          bfd_elf_generic_reloc, /* special_function */
1091          "R_SH_GOTPLT_HI16",    /* name */
1092          false,                 /* partial_inplace */
1093          0,                     /* src_mask */
1094          0x3fffc00,             /* dst_mask */
1095          false),                /* pcrel_offset */
1096
1097   /* Used in MOVI and SHORI (x & 65536).  */
1098   HOWTO (R_SH_PLT_LOW16,        /* type */
1099          0,                     /* rightshift */
1100          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1101          64,                    /* bitsize */
1102          true,                  /* pc_relative */
1103          10,                    /* bitpos */
1104          complain_overflow_dont, /* complain_on_overflow */
1105          bfd_elf_generic_reloc, /* special_function */
1106          "R_SH_PLT_LOW16",      /* name */
1107          false,                 /* partial_inplace */
1108          0,                     /* src_mask */
1109          0x3fffc00,             /* dst_mask */
1110          true),                 /* pcrel_offset */
1111
1112   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
1113   HOWTO (R_SH_PLT_MEDLOW16,     /* type */
1114          16,                    /* rightshift */
1115          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1116          64,                    /* bitsize */
1117          true,                  /* pc_relative */
1118          10,                    /* bitpos */
1119          complain_overflow_dont, /* complain_on_overflow */
1120          bfd_elf_generic_reloc, /* special_function */
1121          "R_SH_PLT_MEDLOW16",   /* name */
1122          false,                 /* partial_inplace */
1123          0,                     /* src_mask */
1124          0x3fffc00,             /* dst_mask */
1125          true),                 /* pcrel_offset */
1126
1127   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1128   HOWTO (R_SH_PLT_MEDHI16,      /* type */
1129          32,                    /* rightshift */
1130          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1131          64,                    /* bitsize */
1132          true,                  /* pc_relative */
1133          10,                    /* bitpos */
1134          complain_overflow_dont, /* complain_on_overflow */
1135          bfd_elf_generic_reloc, /* special_function */
1136          "R_SH_PLT_MEDHI16",    /* name */
1137          false,                 /* partial_inplace */
1138          0,                     /* src_mask */
1139          0x3fffc00,             /* dst_mask */
1140          true),                 /* pcrel_offset */
1141
1142   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1143   HOWTO (R_SH_PLT_HI16,         /* type */
1144          48,                    /* rightshift */
1145          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1146          64,                    /* bitsize */
1147          true,                  /* pc_relative */
1148          10,                    /* bitpos */
1149          complain_overflow_dont, /* complain_on_overflow */
1150          bfd_elf_generic_reloc, /* special_function */
1151          "R_SH_PLT_HI16",       /* name */
1152          false,                 /* partial_inplace */
1153          0,                     /* src_mask */
1154          0x3fffc00,             /* dst_mask */
1155          true),                 /* pcrel_offset */
1156
1157   /* Used in MOVI and SHORI (x & 65536).  */
1158   HOWTO (R_SH_GOTOFF_LOW16,     /* type */
1159          0,                     /* rightshift */
1160          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1161          64,                    /* bitsize */
1162          false,                 /* pc_relative */
1163          10,                    /* bitpos */
1164          complain_overflow_dont, /* complain_on_overflow */
1165          bfd_elf_generic_reloc, /* special_function */
1166          "R_SH_GOTOFF_LOW16",   /* name */
1167          false,                 /* partial_inplace */
1168          0,                     /* src_mask */
1169          0x3fffc00,             /* dst_mask */
1170          false),                /* pcrel_offset */
1171
1172   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
1173   HOWTO (R_SH_GOTOFF_MEDLOW16,  /* type */
1174          16,                    /* rightshift */
1175          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1176          64,                    /* bitsize */
1177          false,                 /* pc_relative */
1178          10,                    /* bitpos */
1179          complain_overflow_dont, /* complain_on_overflow */
1180          bfd_elf_generic_reloc, /* special_function */
1181          "R_SH_GOTOFF_MEDLOW16", /* name */
1182          false,                 /* partial_inplace */
1183          0,                     /* src_mask */
1184          0x3fffc00,             /* dst_mask */
1185          false),                /* pcrel_offset */
1186
1187   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1188   HOWTO (R_SH_GOTOFF_MEDHI16,   /* type */
1189          32,                    /* rightshift */
1190          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1191          64,                    /* bitsize */
1192          false,                 /* pc_relative */
1193          10,                    /* bitpos */
1194          complain_overflow_dont, /* complain_on_overflow */
1195          bfd_elf_generic_reloc, /* special_function */
1196          "R_SH_GOTOFF_MEDHI16", /* name */
1197          false,                 /* partial_inplace */
1198          0,                     /* src_mask */
1199          0x3fffc00,             /* dst_mask */
1200          false),                /* pcrel_offset */
1201
1202   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1203   HOWTO (R_SH_GOTOFF_HI16,      /* type */
1204          48,                    /* rightshift */
1205          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1206          64,                    /* bitsize */
1207          false,                 /* pc_relative */
1208          10,                    /* bitpos */
1209          complain_overflow_dont, /* complain_on_overflow */
1210          bfd_elf_generic_reloc, /* special_function */
1211          "R_SH_GOTOFF_HI16",    /* name */
1212          false,                 /* partial_inplace */
1213          0,                     /* src_mask */
1214          0x3fffc00,             /* dst_mask */
1215          false),                /* pcrel_offset */
1216
1217   /* Used in MOVI and SHORI (x & 65536).  */
1218   HOWTO (R_SH_GOTPC_LOW16,      /* type */
1219          0,                     /* rightshift */
1220          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1221          64,                    /* bitsize */
1222          true,                  /* pc_relative */
1223          10,                    /* bitpos */
1224          complain_overflow_dont, /* complain_on_overflow */
1225          bfd_elf_generic_reloc, /* special_function */
1226          "R_SH_GOTPC_LOW16",    /* name */
1227          false,                 /* partial_inplace */
1228          0,                     /* src_mask */
1229          0x3fffc00,             /* dst_mask */
1230          true),                 /* pcrel_offset */
1231
1232   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
1233   HOWTO (R_SH_GOTPC_MEDLOW16,   /* type */
1234          16,                    /* rightshift */
1235          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1236          64,                    /* bitsize */
1237          true,                  /* pc_relative */
1238          10,                    /* bitpos */
1239          complain_overflow_dont, /* complain_on_overflow */
1240          bfd_elf_generic_reloc, /* special_function */
1241          "R_SH_GOTPC_MEDLOW16", /* name */
1242          false,                 /* partial_inplace */
1243          0,                     /* src_mask */
1244          0x3fffc00,             /* dst_mask */
1245          true),                 /* pcrel_offset */
1246
1247   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1248   HOWTO (R_SH_GOTPC_MEDHI16,    /* type */
1249          32,                    /* rightshift */
1250          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1251          64,                    /* bitsize */
1252          true,                  /* pc_relative */
1253          10,                    /* bitpos */
1254          complain_overflow_dont, /* complain_on_overflow */
1255          bfd_elf_generic_reloc, /* special_function */
1256          "R_SH_GOTPC_MEDHI16",  /* name */
1257          false,                 /* partial_inplace */
1258          0,                     /* src_mask */
1259          0x3fffc00,             /* dst_mask */
1260          true),                 /* pcrel_offset */
1261
1262   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1263   HOWTO (R_SH_GOTPC_HI16,       /* type */
1264          48,                    /* rightshift */
1265          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1266          64,                    /* bitsize */
1267          true,                  /* pc_relative */
1268          10,                    /* bitpos */
1269          complain_overflow_dont, /* complain_on_overflow */
1270          bfd_elf_generic_reloc, /* special_function */
1271          "R_SH_GOTPC_HI16",     /* name */
1272          false,                 /* partial_inplace */
1273          0,                     /* src_mask */
1274          0x3fffc00,             /* dst_mask */
1275          true),                 /* pcrel_offset */
1276
1277   /* Used in LD.L, FLD.S et al.  */
1278   HOWTO (R_SH_GOT10BY4,         /* type */
1279          2,                     /* rightshift */
1280          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1281          12,                    /* bitsize */
1282          false,                 /* pc_relative */
1283          10,                    /* bitpos */
1284          complain_overflow_signed, /* complain_on_overflow */
1285          bfd_elf_generic_reloc, /* special_function */
1286          "R_SH_GOT10BY4",       /* name */
1287          false,                 /* partial_inplace */
1288          0,                     /* src_mask */
1289          0xffc00,               /* dst_mask */
1290          false),                /* pcrel_offset */
1291
1292   /* Used in LD.L, FLD.S et al.  */
1293   HOWTO (R_SH_GOTPLT10BY4,      /* type */
1294          2,                     /* rightshift */
1295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1296          12,                    /* bitsize */
1297          false,                 /* pc_relative */
1298          10,                    /* bitpos */
1299          complain_overflow_signed, /* complain_on_overflow */
1300          bfd_elf_generic_reloc, /* special_function */
1301          "R_SH_GOTPLT10BY4",    /* name */
1302          false,                 /* partial_inplace */
1303          0,                     /* src_mask */
1304          0xffc00,               /* dst_mask */
1305          false),                /* pcrel_offset */
1306
1307   /* Used in FLD.D, FST.P et al.  */
1308   HOWTO (R_SH_GOT10BY8,         /* type */
1309          3,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          13,                    /* bitsize */
1312          false,                 /* pc_relative */
1313          10,                    /* bitpos */
1314          complain_overflow_signed, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_SH_GOT10BY8",       /* name */
1317          false,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0xffc00,               /* dst_mask */
1320          false),                /* pcrel_offset */
1321
1322   /* Used in FLD.D, FST.P et al.  */
1323   HOWTO (R_SH_GOTPLT10BY8,      /* type */
1324          3,                     /* rightshift */
1325          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1326          13,                    /* bitsize */
1327          false,                 /* pc_relative */
1328          10,                    /* bitpos */
1329          complain_overflow_signed, /* complain_on_overflow */
1330          bfd_elf_generic_reloc, /* special_function */
1331          "R_SH_GOTPLT10BY8",    /* name */
1332          false,                 /* partial_inplace */
1333          0,                     /* src_mask */
1334          0xffc00,               /* dst_mask */
1335          false),                /* pcrel_offset */
1336
1337   HOWTO (R_SH_COPY64,           /* type */
1338          0,                     /* rightshift */
1339          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1340          64,                    /* bitsize */
1341          false,                 /* pc_relative */
1342          0,                     /* bitpos */
1343          complain_overflow_dont, /* complain_on_overflow */
1344          bfd_elf_generic_reloc, /* special_function */
1345          "R_SH_COPY64",         /* name */
1346          false,                 /* partial_inplace */
1347          0,                     /* src_mask */
1348          ((bfd_vma) 0) - 1,     /* dst_mask */
1349          false),                /* pcrel_offset */
1350
1351   HOWTO (R_SH_GLOB_DAT64,       /* type */
1352          0,                     /* rightshift */
1353          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1354          64,                    /* bitsize */
1355          false,                 /* pc_relative */
1356          0,                     /* bitpos */
1357          complain_overflow_dont, /* complain_on_overflow */
1358          bfd_elf_generic_reloc, /* special_function */
1359          "R_SH_GLOB_DAT64",     /* name */
1360          false,                 /* partial_inplace */
1361          0,                     /* src_mask */
1362          ((bfd_vma) 0) - 1,     /* dst_mask */
1363          false),                /* pcrel_offset */
1364
1365   HOWTO (R_SH_JMP_SLOT64,       /* type */
1366          0,                     /* rightshift */
1367          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1368          64,                    /* bitsize */
1369          false,                 /* pc_relative */
1370          0,                     /* bitpos */
1371          complain_overflow_dont, /* complain_on_overflow */
1372          bfd_elf_generic_reloc, /* special_function */
1373          "R_SH_JMP_SLOT64",     /* name */
1374          false,                 /* partial_inplace */
1375          0,                     /* src_mask */
1376          ((bfd_vma) 0) - 1,     /* dst_mask */
1377          false),                /* pcrel_offset */
1378
1379   HOWTO (R_SH_RELATIVE64,       /* type */
1380          0,                     /* rightshift */
1381          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          64,                    /* bitsize */
1383          false,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_dont, /* complain_on_overflow */
1386          bfd_elf_generic_reloc, /* special_function */
1387          "R_SH_RELATIVE64",     /* name */
1388          false,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          ((bfd_vma) 0) - 1,     /* dst_mask */
1391          false),                /* pcrel_offset */
1392
1393   EMPTY_HOWTO (197),
1394   EMPTY_HOWTO (198),
1395   EMPTY_HOWTO (199),
1396   EMPTY_HOWTO (200),
1397   EMPTY_HOWTO (201),
1398   EMPTY_HOWTO (202),
1399   EMPTY_HOWTO (203),
1400   EMPTY_HOWTO (204),
1401   EMPTY_HOWTO (205),
1402   EMPTY_HOWTO (206),
1403   EMPTY_HOWTO (207),
1404   EMPTY_HOWTO (208),
1405   EMPTY_HOWTO (209),
1406   EMPTY_HOWTO (210),
1407   EMPTY_HOWTO (211),
1408   EMPTY_HOWTO (212),
1409   EMPTY_HOWTO (213),
1410   EMPTY_HOWTO (214),
1411   EMPTY_HOWTO (215),
1412   EMPTY_HOWTO (216),
1413   EMPTY_HOWTO (217),
1414   EMPTY_HOWTO (218),
1415   EMPTY_HOWTO (219),
1416   EMPTY_HOWTO (220),
1417   EMPTY_HOWTO (221),
1418   EMPTY_HOWTO (222),
1419   EMPTY_HOWTO (223),
1420   EMPTY_HOWTO (224),
1421   EMPTY_HOWTO (225),
1422   EMPTY_HOWTO (226),
1423   EMPTY_HOWTO (227),
1424   EMPTY_HOWTO (228),
1425   EMPTY_HOWTO (229),
1426   EMPTY_HOWTO (230),
1427   EMPTY_HOWTO (231),
1428   EMPTY_HOWTO (232),
1429   EMPTY_HOWTO (233),
1430   EMPTY_HOWTO (234),
1431   EMPTY_HOWTO (235),
1432   EMPTY_HOWTO (236),
1433   EMPTY_HOWTO (237),
1434   EMPTY_HOWTO (238),
1435   EMPTY_HOWTO (239),
1436   EMPTY_HOWTO (240),
1437   EMPTY_HOWTO (241),
1438
1439   /* Relocations for SHmedia code.  None of these are partial_inplace or
1440      use the field being relocated (except R_SH_PT_16).  */
1441
1442   /* The assembler will generate this reloc before a block of SHmedia
1443      instructions.  A section should be processed as assuming it contains
1444      data, unless this reloc is seen.  Note that a block of SHcompact
1445      instructions are instead preceded by R_SH_CODE.
1446      This is currently not implemented, but should be used for SHmedia
1447      linker relaxation.  */
1448   HOWTO (R_SH_SHMEDIA_CODE,     /* type */
1449          0,                     /* rightshift */
1450          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1451          0,                     /* bitsize */
1452          false,                 /* pc_relative */
1453          0,                     /* bitpos */
1454          complain_overflow_unsigned, /* complain_on_overflow */
1455          sh_elf_ignore_reloc,   /* special_function */
1456          "R_SH_SHMEDIA_CODE",   /* name */
1457          false,                 /* partial_inplace */
1458          0,                     /* src_mask */
1459          0,                     /* dst_mask */
1460          false),                /* pcrel_offset */
1461
1462   /* The assembler will generate this reloc at a PTA or PTB instruction,
1463      and the linker checks the right type of target, or changes a PTA to a
1464      PTB, if the original insn was PT.  */
1465   HOWTO (R_SH_PT_16,            /* type */
1466          2,                     /* rightshift */
1467          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1468          18,                    /* bitsize */
1469          true,                  /* pc_relative */
1470          10,                    /* bitpos */
1471          complain_overflow_signed, /* complain_on_overflow */
1472          bfd_elf_generic_reloc, /* special_function */
1473          "R_SH_PT_16",          /* name */
1474          false,                 /* partial_inplace */
1475          0,                     /* src_mask */
1476          0x3fffc00,             /* dst_mask */
1477          true),                 /* pcrel_offset */
1478
1479   /* Used in unexpanded MOVI.  */
1480   HOWTO (R_SH_IMMS16,           /* type */
1481          0,                     /* rightshift */
1482          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1483          16,                    /* bitsize */
1484          false,                 /* pc_relative */
1485          10,                    /* bitpos */
1486          complain_overflow_signed, /* complain_on_overflow */
1487          bfd_elf_generic_reloc, /* special_function */
1488          "R_SH_IMMS16",         /* name */
1489          false,                 /* partial_inplace */
1490          0,                     /* src_mask */
1491          0x3fffc00,             /* dst_mask */
1492          false),                /* pcrel_offset */
1493
1494   /* Used in SHORI.  */
1495   HOWTO (R_SH_IMMU16,           /* type */
1496          0,                     /* rightshift */
1497          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1498          16,                    /* bitsize */
1499          false,                 /* pc_relative */
1500          10,                    /* bitpos */
1501          complain_overflow_unsigned, /* complain_on_overflow */
1502          bfd_elf_generic_reloc, /* special_function */
1503          "R_SH_IMMU16",         /* name */
1504          false,                 /* partial_inplace */
1505          0,                     /* src_mask */
1506          0x3fffc00,             /* dst_mask */
1507          false),                /* pcrel_offset */
1508
1509   /* Used in MOVI and SHORI (x & 65536).  */
1510   HOWTO (R_SH_IMM_LOW16,        /* type */
1511          0,                     /* rightshift */
1512          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1513          64,                    /* bitsize */
1514          false,                 /* pc_relative */
1515          10,                    /* bitpos */
1516          complain_overflow_dont, /* complain_on_overflow */
1517          bfd_elf_generic_reloc, /* special_function */
1518          "R_SH_IMM_LOW16",      /* name */
1519          false,                 /* partial_inplace */
1520          0,                     /* src_mask */
1521          0x3fffc00,             /* dst_mask */
1522          false),                /* pcrel_offset */
1523
1524   /* Used in MOVI and SHORI ((x - $) & 65536).  */
1525   HOWTO (R_SH_IMM_LOW16_PCREL,  /* type */
1526          0,                     /* rightshift */
1527          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1528          64,                    /* bitsize */
1529          true,                  /* pc_relative */
1530          10,                    /* bitpos */
1531          complain_overflow_dont, /* complain_on_overflow */
1532          bfd_elf_generic_reloc, /* special_function */
1533          "R_SH_IMM_LOW16_PCREL", /* name */
1534          false,                 /* partial_inplace */
1535          0,                     /* src_mask */
1536          0x3fffc00,             /* dst_mask */
1537          true),                 /* pcrel_offset */
1538
1539   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
1540   HOWTO (R_SH_IMM_MEDLOW16,     /* type */
1541          16,                    /* rightshift */
1542          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1543          64,                    /* bitsize */
1544          false,                 /* pc_relative */
1545          10,                    /* bitpos */
1546          complain_overflow_dont, /* complain_on_overflow */
1547          bfd_elf_generic_reloc, /* special_function */
1548          "R_SH_IMM_MEDLOW16",   /* name */
1549          false,                 /* partial_inplace */
1550          0,                     /* src_mask */
1551          0x3fffc00,             /* dst_mask */
1552          false),                /* pcrel_offset */
1553
1554   /* Used in MOVI and SHORI (((x - $) >> 16) & 65536).  */
1555   HOWTO (R_SH_IMM_MEDLOW16_PCREL, /* type */
1556          16,                    /* rightshift */
1557          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1558          64,                    /* bitsize */
1559          true,                  /* pc_relative */
1560          10,                    /* bitpos */
1561          complain_overflow_dont, /* complain_on_overflow */
1562          bfd_elf_generic_reloc, /* special_function */
1563          "R_SH_IMM_MEDLOW16_PCREL", /* name */
1564          false,                 /* partial_inplace */
1565          0,                     /* src_mask */
1566          0x3fffc00,             /* dst_mask */
1567          true),                 /* pcrel_offset */
1568
1569   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1570   HOWTO (R_SH_IMM_MEDHI16,      /* type */
1571          32,                    /* rightshift */
1572          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1573          64,                    /* bitsize */
1574          false,                 /* pc_relative */
1575          10,                    /* bitpos */
1576          complain_overflow_dont, /* complain_on_overflow */
1577          bfd_elf_generic_reloc, /* special_function */
1578          "R_SH_IMM_MEDHI16",    /* name */
1579          false,                 /* partial_inplace */
1580          0,                     /* src_mask */
1581          0x3fffc00,             /* dst_mask */
1582          false),                /* pcrel_offset */
1583
1584   /* Used in MOVI and SHORI (((x - $) >> 32) & 65536).  */
1585   HOWTO (R_SH_IMM_MEDHI16_PCREL, /* type */
1586          32,                    /* rightshift */
1587          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1588          64,                    /* bitsize */
1589          true,                  /* pc_relative */
1590          10,                    /* bitpos */
1591          complain_overflow_dont, /* complain_on_overflow */
1592          bfd_elf_generic_reloc, /* special_function */
1593          "R_SH_IMM_MEDHI16_PCREL", /* name */
1594          false,                 /* partial_inplace */
1595          0,                     /* src_mask */
1596          0x3fffc00,             /* dst_mask */
1597          true),                 /* pcrel_offset */
1598
1599   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1600   HOWTO (R_SH_IMM_HI16,         /* type */
1601          48,                    /* rightshift */
1602          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1603          64,                    /* bitsize */
1604          false,                 /* pc_relative */
1605          10,                    /* bitpos */
1606          complain_overflow_dont, /* complain_on_overflow */
1607          bfd_elf_generic_reloc, /* special_function */
1608          "R_SH_IMM_HI16",       /* name */
1609          false,                 /* partial_inplace */
1610          0,                     /* src_mask */
1611          0x3fffc00,             /* dst_mask */
1612          false),                /* pcrel_offset */
1613
1614   /* Used in MOVI and SHORI (((x - $) >> 48) & 65536).  */
1615   HOWTO (R_SH_IMM_HI16_PCREL,   /* type */
1616          48,                    /* rightshift */
1617          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1618          64,                    /* bitsize */
1619          true,                  /* pc_relative */
1620          10,                    /* bitpos */
1621          complain_overflow_dont, /* complain_on_overflow */
1622          bfd_elf_generic_reloc, /* special_function */
1623          "R_SH_IMM_HI16_PCREL", /* name */
1624          false,                 /* partial_inplace */
1625          0,                     /* src_mask */
1626          0x3fffc00,             /* dst_mask */
1627          true),                 /* pcrel_offset */
1628
1629   /* For the .uaquad pseudo.  */
1630   HOWTO (R_SH_64,               /* type */
1631          0,                     /* rightshift */
1632          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1633          64,                    /* bitsize */
1634          false,                 /* pc_relative */
1635          0,                     /* bitpos */
1636          complain_overflow_dont, /* complain_on_overflow */
1637          bfd_elf_generic_reloc, /* special_function */
1638          "R_SH_64",             /* name */
1639          false,                 /* partial_inplace */
1640          0,                     /* src_mask */
1641          ((bfd_vma) 0) - 1,     /* dst_mask */
1642          false),                /* pcrel_offset */
1643
1644   /* For the .uaquad pseudo, (x - $).  */
1645   HOWTO (R_SH_64_PCREL,         /* type */
1646          48,                    /* rightshift */
1647          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1648          64,                    /* bitsize */
1649          true,                  /* pc_relative */
1650          10,                    /* bitpos */
1651          complain_overflow_dont, /* complain_on_overflow */
1652          bfd_elf_generic_reloc, /* special_function */
1653          "R_SH_64_PCREL",       /* name */
1654          false,                 /* partial_inplace */
1655          0,                     /* src_mask */
1656          ((bfd_vma) 0) - 1,     /* dst_mask */
1657          true),                 /* pcrel_offset */
1658
1659 #endif
1660 };
1661
1662 static bfd_reloc_status_type
1663 sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr,
1664                    symbol_section, start, end)
1665      int r_type ATTRIBUTE_UNUSED;
1666      bfd *input_bfd;
1667      asection *input_section;
1668      bfd_byte *contents;
1669      bfd_vma addr;
1670      asection *symbol_section;
1671      bfd_vma start, end;
1672 {
1673   static bfd_vma last_addr;
1674   static asection *last_symbol_section;
1675   bfd_byte *start_ptr, *ptr, *last_ptr;
1676   int diff, cum_diff;
1677   bfd_signed_vma x;
1678   int insn;
1679
1680   /* Sanity check the address.  */
1681   if (addr > input_section->_raw_size)
1682     return bfd_reloc_outofrange;
1683
1684   /* We require the start and end relocations to be processed consecutively -
1685      although we allow then to be processed forwards or backwards.  */
1686   if (! last_addr)
1687     {
1688       last_addr = addr;
1689       last_symbol_section = symbol_section;
1690       return bfd_reloc_ok;
1691     }
1692   if (last_addr != addr)
1693     abort ();
1694   last_addr = 0;
1695
1696   if (! symbol_section || last_symbol_section != symbol_section || end < start)
1697     return bfd_reloc_outofrange;
1698
1699   /* Get the symbol_section contents.  */
1700   if (symbol_section != input_section)
1701     {
1702       if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
1703         contents = elf_section_data (symbol_section)->this_hdr.contents;
1704       else
1705         {
1706           contents = (bfd_byte *) bfd_malloc (symbol_section->_raw_size);
1707           if (contents == NULL)
1708             return bfd_reloc_outofrange;
1709           if (! bfd_get_section_contents (input_bfd, symbol_section, contents,
1710                                           (file_ptr) 0,
1711                                           symbol_section->_raw_size))
1712             {
1713               free (contents);
1714               return bfd_reloc_outofrange;
1715             }
1716         }
1717     }
1718 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
1719   start_ptr = contents + start;
1720   for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
1721     {
1722       for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
1723         ptr -= 2;
1724       ptr += 2;
1725       diff = (last_ptr - ptr) >> 1;
1726       cum_diff += diff & 1;
1727       cum_diff += diff;
1728     }
1729   /* Calculate the start / end values to load into rs / re minus four -
1730      so that will cancel out the four we would otherwise have to add to
1731      addr to get the value to subtract in order to get relative addressing.  */
1732   if (cum_diff >= 0)
1733     {
1734       start -= 4;
1735       end = (ptr + cum_diff * 2) - contents;
1736     }
1737   else
1738     {
1739       bfd_vma start0 = start - 4;
1740
1741       while (start0 && IS_PPI (contents + start0))
1742         start0 -= 2;
1743       start0 = start - 2 - ((start - start0) & 2);
1744       start = start0 - cum_diff - 2;
1745       end = start0;
1746     }
1747
1748   if (contents != NULL
1749       && elf_section_data (symbol_section)->this_hdr.contents != contents)
1750     free (contents);
1751
1752   insn = bfd_get_16 (input_bfd, contents + addr);
1753
1754   x = (insn & 0x200 ? end : start) - addr;
1755   if (input_section != symbol_section)
1756     x += ((symbol_section->output_section->vma + symbol_section->output_offset)
1757           - (input_section->output_section->vma
1758              + input_section->output_offset));
1759   x >>= 1;
1760   if (x < -128 || x > 127)
1761     return bfd_reloc_overflow;
1762
1763   x = (insn & ~0xff) | (x & 0xff);
1764   bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr);
1765
1766   return bfd_reloc_ok;
1767 }
1768
1769 /* This function is used for normal relocs.  This used to be like the COFF
1770    function, and is almost certainly incorrect for other ELF targets.  */
1771
1772 static bfd_reloc_status_type
1773 sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
1774               error_message)
1775      bfd *abfd;
1776      arelent *reloc_entry;
1777      asymbol *symbol_in;
1778      PTR data;
1779      asection *input_section;
1780      bfd *output_bfd;
1781      char **error_message ATTRIBUTE_UNUSED;
1782 {
1783   unsigned long insn;
1784   bfd_vma sym_value;
1785   enum elf_sh_reloc_type r_type;
1786   bfd_vma addr = reloc_entry->address;
1787   bfd_byte *hit_data = addr + (bfd_byte *) data;
1788
1789   r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
1790
1791   if (output_bfd != NULL)
1792     {
1793       /* Partial linking--do nothing.  */
1794       reloc_entry->address += input_section->output_offset;
1795       return bfd_reloc_ok;
1796     }
1797
1798   /* Almost all relocs have to do with relaxing.  If any work must be
1799      done for them, it has been done in sh_relax_section.  */
1800   if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
1801     return bfd_reloc_ok;
1802
1803   if (symbol_in != NULL
1804       && bfd_is_und_section (symbol_in->section))
1805     return bfd_reloc_undefined;
1806
1807   if (bfd_is_com_section (symbol_in->section))
1808     sym_value = 0;
1809   else
1810     sym_value = (symbol_in->value +
1811                  symbol_in->section->output_section->vma +
1812                  symbol_in->section->output_offset);
1813
1814   switch (r_type)
1815     {
1816     case R_SH_DIR32:
1817       insn = bfd_get_32 (abfd, hit_data);
1818       insn += sym_value + reloc_entry->addend;
1819       bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
1820       break;
1821     case R_SH_IND12W:
1822       insn = bfd_get_16 (abfd, hit_data);
1823       sym_value += reloc_entry->addend;
1824       sym_value -= (input_section->output_section->vma
1825                     + input_section->output_offset
1826                     + addr
1827                     + 4);
1828       sym_value += (insn & 0xfff) << 1;
1829       if (insn & 0x800)
1830         sym_value -= 0x1000;
1831       insn = (insn & 0xf000) | (sym_value & 0xfff);
1832       bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
1833       if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
1834         return bfd_reloc_overflow;
1835       break;
1836     default:
1837       abort ();
1838       break;
1839     }
1840
1841   return bfd_reloc_ok;
1842 }
1843
1844 /* This function is used for relocs which are only used for relaxing,
1845    which the linker should otherwise ignore.  */
1846
1847 static bfd_reloc_status_type
1848 sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
1849                      output_bfd, error_message)
1850      bfd *abfd ATTRIBUTE_UNUSED;
1851      arelent *reloc_entry;
1852      asymbol *symbol ATTRIBUTE_UNUSED;
1853      PTR data ATTRIBUTE_UNUSED;
1854      asection *input_section;
1855      bfd *output_bfd;
1856      char **error_message ATTRIBUTE_UNUSED;
1857 {
1858   if (output_bfd != NULL)
1859     reloc_entry->address += input_section->output_offset;
1860   return bfd_reloc_ok;
1861 }
1862
1863 /* This structure is used to map BFD reloc codes to SH ELF relocs.  */
1864
1865 struct elf_reloc_map
1866 {
1867   bfd_reloc_code_real_type bfd_reloc_val;
1868   unsigned char elf_reloc_val;
1869 };
1870
1871 /* An array mapping BFD reloc codes to SH ELF relocs.  */
1872
1873 static const struct elf_reloc_map sh_reloc_map[] =
1874 {
1875   { BFD_RELOC_NONE, R_SH_NONE },
1876   { BFD_RELOC_32, R_SH_DIR32 },
1877   { BFD_RELOC_CTOR, R_SH_DIR32 },
1878   { BFD_RELOC_32_PCREL, R_SH_REL32 },
1879   { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
1880   { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
1881   { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
1882   { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
1883   { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
1884   { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
1885   { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
1886   { BFD_RELOC_SH_USES, R_SH_USES },
1887   { BFD_RELOC_SH_COUNT, R_SH_COUNT },
1888   { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
1889   { BFD_RELOC_SH_CODE, R_SH_CODE },
1890   { BFD_RELOC_SH_DATA, R_SH_DATA },
1891   { BFD_RELOC_SH_LABEL, R_SH_LABEL },
1892   { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
1893   { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
1894   { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
1895   { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
1896   { BFD_RELOC_SH_TLS_GD_32, R_SH_TLS_GD_32 },
1897   { BFD_RELOC_SH_TLS_LD_32, R_SH_TLS_LD_32 },
1898   { BFD_RELOC_SH_TLS_LDO_32, R_SH_TLS_LDO_32 },
1899   { BFD_RELOC_SH_TLS_IE_32, R_SH_TLS_IE_32 },
1900   { BFD_RELOC_SH_TLS_LE_32, R_SH_TLS_LE_32 },
1901   { BFD_RELOC_SH_TLS_DTPMOD32, R_SH_TLS_DTPMOD32 },
1902   { BFD_RELOC_SH_TLS_DTPOFF32, R_SH_TLS_DTPOFF32 },
1903   { BFD_RELOC_SH_TLS_TPOFF32, R_SH_TLS_TPOFF32 },
1904   { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
1905   { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
1906   { BFD_RELOC_SH_COPY, R_SH_COPY },
1907   { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
1908   { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
1909   { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
1910   { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
1911   { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
1912   { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 },
1913 #ifdef INCLUDE_SHMEDIA
1914   { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
1915   { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
1916   { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
1917   { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
1918   { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
1919   { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
1920   { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
1921   { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
1922   { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
1923   { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
1924   { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
1925   { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
1926   { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
1927   { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
1928   { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
1929   { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
1930   { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
1931   { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
1932   { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
1933   { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
1934   { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
1935   { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
1936   { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
1937   { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
1938   { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
1939   { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
1940   { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
1941   { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
1942   { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
1943   { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
1944   { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
1945   { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
1946   { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
1947   { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
1948   { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
1949   { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
1950   { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
1951   { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
1952   { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
1953   { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
1954   { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
1955   { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
1956   { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
1957   { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
1958   { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
1959   { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
1960   { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
1961   { BFD_RELOC_64, R_SH_64 },
1962   { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
1963 #endif /* not INCLUDE_SHMEDIA */
1964 };
1965
1966 /* Given a BFD reloc code, return the howto structure for the
1967    corresponding SH ELf reloc.  */
1968
1969 static reloc_howto_type *
1970 sh_elf_reloc_type_lookup (abfd, code)
1971      bfd *abfd ATTRIBUTE_UNUSED;
1972      bfd_reloc_code_real_type code;
1973 {
1974   unsigned int i;
1975
1976   for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
1977     {
1978       if (sh_reloc_map[i].bfd_reloc_val == code)
1979         return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
1980     }
1981
1982   return NULL;
1983 }
1984
1985 /* Given an ELF reloc, fill in the howto field of a relent.  */
1986
1987 static void
1988 sh_elf_info_to_howto (abfd, cache_ptr, dst)
1989      bfd *abfd ATTRIBUTE_UNUSED;
1990      arelent *cache_ptr;
1991      Elf_Internal_Rela *dst;
1992 {
1993   unsigned int r;
1994
1995   r = ELF32_R_TYPE (dst->r_info);
1996
1997   BFD_ASSERT (r < (unsigned int) R_SH_max);
1998   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
1999   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2);
2000   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_LAST_INVALID_RELOC_3);
2001   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
2002   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_5 || r > R_SH_LAST_INVALID_RELOC_5);
2003
2004   cache_ptr->howto = &sh_elf_howto_table[r];
2005 }
2006 \f
2007 /* This function handles relaxing for SH ELF.  See the corresponding
2008    function in coff-sh.c for a description of what this does.  FIXME:
2009    There is a lot of duplication here between this code and the COFF
2010    specific code.  The format of relocs and symbols is wound deeply
2011    into this code, but it would still be better if the duplication
2012    could be eliminated somehow.  Note in particular that although both
2013    functions use symbols like R_SH_CODE, those symbols have different
2014    values; in coff-sh.c they come from include/coff/sh.h, whereas here
2015    they come from enum elf_sh_reloc_type in include/elf/sh.h.  */
2016
2017 static boolean
2018 sh_elf_relax_section (abfd, sec, link_info, again)
2019      bfd *abfd;
2020      asection *sec;
2021      struct bfd_link_info *link_info;
2022      boolean *again;
2023 {
2024   Elf_Internal_Shdr *symtab_hdr;
2025   Elf_Internal_Rela *internal_relocs;
2026   boolean have_code;
2027   Elf_Internal_Rela *irel, *irelend;
2028   bfd_byte *contents = NULL;
2029   Elf_Internal_Sym *isymbuf = NULL;
2030
2031   *again = false;
2032
2033   if (link_info->relocateable
2034       || (sec->flags & SEC_RELOC) == 0
2035       || sec->reloc_count == 0)
2036     return true;
2037
2038 #ifdef INCLUDE_SHMEDIA
2039   if (elf_section_data (sec)->this_hdr.sh_flags
2040       & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
2041     {
2042       return true;
2043     }
2044 #endif
2045
2046   /* If this is the first time we have been called for this section,
2047      initialize the cooked size.  */
2048   if (sec->_cooked_size == 0)
2049     sec->_cooked_size = sec->_raw_size;
2050
2051   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2052
2053   internal_relocs = (_bfd_elf32_link_read_relocs
2054                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2055                       link_info->keep_memory));
2056   if (internal_relocs == NULL)
2057     goto error_return;
2058
2059   have_code = false;
2060
2061   irelend = internal_relocs + sec->reloc_count;
2062   for (irel = internal_relocs; irel < irelend; irel++)
2063     {
2064       bfd_vma laddr, paddr, symval;
2065       unsigned short insn;
2066       Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
2067       bfd_signed_vma foff;
2068
2069       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
2070         have_code = true;
2071
2072       if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
2073         continue;
2074
2075       /* Get the section contents.  */
2076       if (contents == NULL)
2077         {
2078           if (elf_section_data (sec)->this_hdr.contents != NULL)
2079             contents = elf_section_data (sec)->this_hdr.contents;
2080           else
2081             {
2082               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2083               if (contents == NULL)
2084                 goto error_return;
2085
2086               if (! bfd_get_section_contents (abfd, sec, contents,
2087                                               (file_ptr) 0, sec->_raw_size))
2088                 goto error_return;
2089             }
2090         }
2091
2092       /* The r_addend field of the R_SH_USES reloc will point us to
2093          the register load.  The 4 is because the r_addend field is
2094          computed as though it were a jump offset, which are based
2095          from 4 bytes after the jump instruction.  */
2096       laddr = irel->r_offset + 4 + irel->r_addend;
2097       if (laddr >= sec->_raw_size)
2098         {
2099           (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
2100                                  bfd_archive_filename (abfd),
2101                                  (unsigned long) irel->r_offset);
2102           continue;
2103         }
2104       insn = bfd_get_16 (abfd, contents + laddr);
2105
2106       /* If the instruction is not mov.l NN,rN, we don't know what to
2107          do.  */
2108       if ((insn & 0xf000) != 0xd000)
2109         {
2110           ((*_bfd_error_handler)
2111            (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
2112             bfd_archive_filename (abfd), (unsigned long) irel->r_offset, insn));
2113           continue;
2114         }
2115
2116       /* Get the address from which the register is being loaded.  The
2117          displacement in the mov.l instruction is quadrupled.  It is a
2118          displacement from four bytes after the movl instruction, but,
2119          before adding in the PC address, two least significant bits
2120          of the PC are cleared.  We assume that the section is aligned
2121          on a four byte boundary.  */
2122       paddr = insn & 0xff;
2123       paddr *= 4;
2124       paddr += (laddr + 4) &~ (bfd_vma) 3;
2125       if (paddr >= sec->_raw_size)
2126         {
2127           ((*_bfd_error_handler)
2128            (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
2129             bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
2130           continue;
2131         }
2132
2133       /* Get the reloc for the address from which the register is
2134          being loaded.  This reloc will tell us which function is
2135          actually being called.  */
2136       for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
2137         if (irelfn->r_offset == paddr
2138             && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
2139           break;
2140       if (irelfn >= irelend)
2141         {
2142           ((*_bfd_error_handler)
2143            (_("%s: 0x%lx: warning: could not find expected reloc"),
2144             bfd_archive_filename (abfd), (unsigned long) paddr));
2145           continue;
2146         }
2147
2148       /* Read this BFD's symbols if we haven't done so already.  */
2149       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2150         {
2151           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2152           if (isymbuf == NULL)
2153             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2154                                             symtab_hdr->sh_info, 0,
2155                                             NULL, NULL, NULL);
2156           if (isymbuf == NULL)
2157             goto error_return;
2158         }
2159
2160       /* Get the value of the symbol referred to by the reloc.  */
2161       if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
2162         {
2163           /* A local symbol.  */
2164           Elf_Internal_Sym *isym;
2165
2166           isym = isymbuf + ELF32_R_SYM (irelfn->r_info);
2167           if (isym->st_shndx
2168               != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
2169             {
2170               ((*_bfd_error_handler)
2171                (_("%s: 0x%lx: warning: symbol in unexpected section"),
2172                 bfd_archive_filename (abfd), (unsigned long) paddr));
2173               continue;
2174             }
2175
2176           symval = (isym->st_value
2177                     + sec->output_section->vma
2178                     + sec->output_offset);
2179         }
2180       else
2181         {
2182           unsigned long indx;
2183           struct elf_link_hash_entry *h;
2184
2185           indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
2186           h = elf_sym_hashes (abfd)[indx];
2187           BFD_ASSERT (h != NULL);
2188           if (h->root.type != bfd_link_hash_defined
2189               && h->root.type != bfd_link_hash_defweak)
2190             {
2191               /* This appears to be a reference to an undefined
2192                  symbol.  Just ignore it--it will be caught by the
2193                  regular reloc processing.  */
2194               continue;
2195             }
2196
2197           symval = (h->root.u.def.value
2198                     + h->root.u.def.section->output_section->vma
2199                     + h->root.u.def.section->output_offset);
2200         }
2201
2202       symval += bfd_get_32 (abfd, contents + paddr);
2203
2204       /* See if this function call can be shortened.  */
2205       foff = (symval
2206               - (irel->r_offset
2207                  + sec->output_section->vma
2208                  + sec->output_offset
2209                  + 4));
2210       if (foff < -0x1000 || foff >= 0x1000)
2211         {
2212           /* After all that work, we can't shorten this function call.  */
2213           continue;
2214         }
2215
2216       /* Shorten the function call.  */
2217
2218       /* For simplicity of coding, we are going to modify the section
2219          contents, the section relocs, and the BFD symbol table.  We
2220          must tell the rest of the code not to free up this
2221          information.  It would be possible to instead create a table
2222          of changes which have to be made, as is done in coff-mips.c;
2223          that would be more work, but would require less memory when
2224          the linker is run.  */
2225
2226       elf_section_data (sec)->relocs = internal_relocs;
2227       elf_section_data (sec)->this_hdr.contents = contents;
2228       symtab_hdr->contents = (unsigned char *) isymbuf;
2229
2230       /* Replace the jsr with a bsr.  */
2231
2232       /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
2233          replace the jsr with a bsr.  */
2234       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
2235       if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
2236         {
2237           /* If this needs to be changed because of future relaxing,
2238              it will be handled here like other internal IND12W
2239              relocs.  */
2240           bfd_put_16 (abfd,
2241                       (bfd_vma) 0xb000 | ((foff >> 1) & 0xfff),
2242                       contents + irel->r_offset);
2243         }
2244       else
2245         {
2246           /* We can't fully resolve this yet, because the external
2247              symbol value may be changed by future relaxing.  We let
2248              the final link phase handle it.  */
2249           bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
2250         }
2251
2252       /* See if there is another R_SH_USES reloc referring to the same
2253          register load.  */
2254       for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
2255         if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
2256             && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
2257           break;
2258       if (irelscan < irelend)
2259         {
2260           /* Some other function call depends upon this register load,
2261              and we have not yet converted that function call.
2262              Indeed, we may never be able to convert it.  There is
2263              nothing else we can do at this point.  */
2264           continue;
2265         }
2266
2267       /* Look for a R_SH_COUNT reloc on the location where the
2268          function address is stored.  Do this before deleting any
2269          bytes, to avoid confusion about the address.  */
2270       for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
2271         if (irelcount->r_offset == paddr
2272             && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
2273           break;
2274
2275       /* Delete the register load.  */
2276       if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
2277         goto error_return;
2278
2279       /* That will change things, so, just in case it permits some
2280          other function call to come within range, we should relax
2281          again.  Note that this is not required, and it may be slow.  */
2282       *again = true;
2283
2284       /* Now check whether we got a COUNT reloc.  */
2285       if (irelcount >= irelend)
2286         {
2287           ((*_bfd_error_handler)
2288            (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
2289             bfd_archive_filename (abfd), (unsigned long) paddr));
2290           continue;
2291         }
2292
2293       /* The number of uses is stored in the r_addend field.  We've
2294          just deleted one.  */
2295       if (irelcount->r_addend == 0)
2296         {
2297           ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
2298                                   bfd_archive_filename (abfd),
2299                                   (unsigned long) paddr));
2300           continue;
2301         }
2302
2303       --irelcount->r_addend;
2304
2305       /* If there are no more uses, we can delete the address.  Reload
2306          the address from irelfn, in case it was changed by the
2307          previous call to sh_elf_relax_delete_bytes.  */
2308       if (irelcount->r_addend == 0)
2309         {
2310           if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
2311             goto error_return;
2312         }
2313
2314       /* We've done all we can with that function call.  */
2315     }
2316
2317   /* Look for load and store instructions that we can align on four
2318      byte boundaries.  */
2319   if (have_code)
2320     {
2321       boolean swapped;
2322
2323       /* Get the section contents.  */
2324       if (contents == NULL)
2325         {
2326           if (elf_section_data (sec)->this_hdr.contents != NULL)
2327             contents = elf_section_data (sec)->this_hdr.contents;
2328           else
2329             {
2330               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2331               if (contents == NULL)
2332                 goto error_return;
2333
2334               if (! bfd_get_section_contents (abfd, sec, contents,
2335                                               (file_ptr) 0, sec->_raw_size))
2336                 goto error_return;
2337             }
2338         }
2339
2340       if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
2341                                 &swapped))
2342         goto error_return;
2343
2344       if (swapped)
2345         {
2346           elf_section_data (sec)->relocs = internal_relocs;
2347           elf_section_data (sec)->this_hdr.contents = contents;
2348           symtab_hdr->contents = (unsigned char *) isymbuf;
2349         }
2350     }
2351
2352   if (isymbuf != NULL
2353       && symtab_hdr->contents != (unsigned char *) isymbuf)
2354     {
2355       if (! link_info->keep_memory)
2356         free (isymbuf);
2357       else
2358         {
2359           /* Cache the symbols for elf_link_input_bfd.  */
2360           symtab_hdr->contents = (unsigned char *) isymbuf;
2361         }
2362     }
2363
2364   if (contents != NULL
2365       && elf_section_data (sec)->this_hdr.contents != contents)
2366     {
2367       if (! link_info->keep_memory)
2368         free (contents);
2369       else
2370         {
2371           /* Cache the section contents for elf_link_input_bfd.  */
2372           elf_section_data (sec)->this_hdr.contents = contents;
2373         }
2374     }
2375
2376   if (internal_relocs != NULL
2377       && elf_section_data (sec)->relocs != internal_relocs)
2378     free (internal_relocs);
2379
2380   return true;
2381
2382  error_return:
2383   if (isymbuf != NULL
2384       && symtab_hdr->contents != (unsigned char *) isymbuf)
2385     free (isymbuf);
2386   if (contents != NULL
2387       && elf_section_data (sec)->this_hdr.contents != contents)
2388     free (contents);
2389   if (internal_relocs != NULL
2390       && elf_section_data (sec)->relocs != internal_relocs)
2391     free (internal_relocs);
2392
2393   return false;
2394 }
2395
2396 /* Delete some bytes from a section while relaxing.  FIXME: There is a
2397    lot of duplication between this function and sh_relax_delete_bytes
2398    in coff-sh.c.  */
2399
2400 static boolean
2401 sh_elf_relax_delete_bytes (abfd, sec, addr, count)
2402      bfd *abfd;
2403      asection *sec;
2404      bfd_vma addr;
2405      int count;
2406 {
2407   Elf_Internal_Shdr *symtab_hdr;
2408   unsigned int sec_shndx;
2409   bfd_byte *contents;
2410   Elf_Internal_Rela *irel, *irelend;
2411   Elf_Internal_Rela *irelalign;
2412   bfd_vma toaddr;
2413   Elf_Internal_Sym *isymbuf, *isym, *isymend;
2414   struct elf_link_hash_entry **sym_hashes;
2415   struct elf_link_hash_entry **end_hashes;
2416   unsigned int symcount;
2417   asection *o;
2418
2419   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2420   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2421
2422   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2423
2424   contents = elf_section_data (sec)->this_hdr.contents;
2425
2426   /* The deletion must stop at the next ALIGN reloc for an aligment
2427      power larger than the number of bytes we are deleting.  */
2428
2429   irelalign = NULL;
2430   toaddr = sec->_cooked_size;
2431
2432   irel = elf_section_data (sec)->relocs;
2433   irelend = irel + sec->reloc_count;
2434   for (; irel < irelend; irel++)
2435     {
2436       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
2437           && irel->r_offset > addr
2438           && count < (1 << irel->r_addend))
2439         {
2440           irelalign = irel;
2441           toaddr = irel->r_offset;
2442           break;
2443         }
2444     }
2445
2446   /* Actually delete the bytes.  */
2447   memmove (contents + addr, contents + addr + count,
2448            (size_t) (toaddr - addr - count));
2449   if (irelalign == NULL)
2450     sec->_cooked_size -= count;
2451   else
2452     {
2453       int i;
2454
2455 #define NOP_OPCODE (0x0009)
2456
2457       BFD_ASSERT ((count & 1) == 0);
2458       for (i = 0; i < count; i += 2)
2459         bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
2460     }
2461
2462   /* Adjust all the relocs.  */
2463   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2464     {
2465       bfd_vma nraddr, stop;
2466       bfd_vma start = 0;
2467       int insn = 0;
2468       int off, adjust, oinsn;
2469       bfd_signed_vma voff = 0;
2470       boolean overflow;
2471
2472       /* Get the new reloc address.  */
2473       nraddr = irel->r_offset;
2474       if ((irel->r_offset > addr
2475            && irel->r_offset < toaddr)
2476           || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
2477               && irel->r_offset == toaddr))
2478         nraddr -= count;
2479
2480       /* See if this reloc was for the bytes we have deleted, in which
2481          case we no longer care about it.  Don't delete relocs which
2482          represent addresses, though.  */
2483       if (irel->r_offset >= addr
2484           && irel->r_offset < addr + count
2485           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
2486           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
2487           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
2488           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
2489         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2490                                      (int) R_SH_NONE);
2491
2492       /* If this is a PC relative reloc, see if the range it covers
2493          includes the bytes we have deleted.  */
2494       switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2495         {
2496         default:
2497           break;
2498
2499         case R_SH_DIR8WPN:
2500         case R_SH_IND12W:
2501         case R_SH_DIR8WPZ:
2502         case R_SH_DIR8WPL:
2503           start = irel->r_offset;
2504           insn = bfd_get_16 (abfd, contents + nraddr);
2505           break;
2506         }
2507
2508       switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2509         {
2510         default:
2511           start = stop = addr;
2512           break;
2513
2514         case R_SH_DIR32:
2515           /* If this reloc is against a symbol defined in this
2516              section, and the symbol will not be adjusted below, we
2517              must check the addend to see it will put the value in
2518              range to be adjusted, and hence must be changed.  */
2519           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2520             {
2521               isym = isymbuf + ELF32_R_SYM (irel->r_info);
2522               if (isym->st_shndx == sec_shndx
2523                   && (isym->st_value <= addr
2524                       || isym->st_value >= toaddr))
2525                 {
2526                   bfd_vma val;
2527
2528                   val = bfd_get_32 (abfd, contents + nraddr);
2529                   val += isym->st_value;
2530                   if (val > addr && val < toaddr)
2531                     bfd_put_32 (abfd, val - count, contents + nraddr);
2532                 }
2533             }
2534           start = stop = addr;
2535           break;
2536
2537         case R_SH_DIR8WPN:
2538           off = insn & 0xff;
2539           if (off & 0x80)
2540             off -= 0x100;
2541           stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
2542           break;
2543
2544         case R_SH_IND12W:
2545           if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
2546             start = stop = addr;
2547           else
2548             {
2549               off = insn & 0xfff;
2550               if (off & 0x800)
2551                 off -= 0x1000;
2552               stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
2553             }
2554           break;
2555
2556         case R_SH_DIR8WPZ:
2557           off = insn & 0xff;
2558           stop = start + 4 + off * 2;
2559           break;
2560
2561         case R_SH_DIR8WPL:
2562           off = insn & 0xff;
2563           stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
2564           break;
2565
2566         case R_SH_SWITCH8:
2567         case R_SH_SWITCH16:
2568         case R_SH_SWITCH32:
2569           /* These relocs types represent
2570                .word L2-L1
2571              The r_addend field holds the difference between the reloc
2572              address and L1.  That is the start of the reloc, and
2573              adding in the contents gives us the top.  We must adjust
2574              both the r_offset field and the section contents.
2575              N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
2576              and the elf bfd r_offset is called r_vaddr.  */
2577
2578           stop = irel->r_offset;
2579           start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
2580
2581           if (start > addr
2582               && start < toaddr
2583               && (stop <= addr || stop >= toaddr))
2584             irel->r_addend += count;
2585           else if (stop > addr
2586                    && stop < toaddr
2587                    && (start <= addr || start >= toaddr))
2588             irel->r_addend -= count;
2589
2590           if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
2591             voff = bfd_get_signed_16 (abfd, contents + nraddr);
2592           else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
2593             voff = bfd_get_8 (abfd, contents + nraddr);
2594           else
2595             voff = bfd_get_signed_32 (abfd, contents + nraddr);
2596           stop = (bfd_vma) ((bfd_signed_vma) start + voff);
2597
2598           break;
2599
2600         case R_SH_USES:
2601           start = irel->r_offset;
2602           stop = (bfd_vma) ((bfd_signed_vma) start
2603                             + (long) irel->r_addend
2604                             + 4);
2605           break;
2606         }
2607
2608       if (start > addr
2609           && start < toaddr
2610           && (stop <= addr || stop >= toaddr))
2611         adjust = count;
2612       else if (stop > addr
2613                && stop < toaddr
2614                && (start <= addr || start >= toaddr))
2615         adjust = - count;
2616       else
2617         adjust = 0;
2618
2619       if (adjust != 0)
2620         {
2621           oinsn = insn;
2622           overflow = false;
2623           switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2624             {
2625             default:
2626               abort ();
2627               break;
2628
2629             case R_SH_DIR8WPN:
2630             case R_SH_DIR8WPZ:
2631               insn += adjust / 2;
2632               if ((oinsn & 0xff00) != (insn & 0xff00))
2633                 overflow = true;
2634               bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
2635               break;
2636
2637             case R_SH_IND12W:
2638               insn += adjust / 2;
2639               if ((oinsn & 0xf000) != (insn & 0xf000))
2640                 overflow = true;
2641               bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
2642               break;
2643
2644             case R_SH_DIR8WPL:
2645               BFD_ASSERT (adjust == count || count >= 4);
2646               if (count >= 4)
2647                 insn += adjust / 4;
2648               else
2649                 {
2650                   if ((irel->r_offset & 3) == 0)
2651                     ++insn;
2652                 }
2653               if ((oinsn & 0xff00) != (insn & 0xff00))
2654                 overflow = true;
2655               bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
2656               break;
2657
2658             case R_SH_SWITCH8:
2659               voff += adjust;
2660               if (voff < 0 || voff >= 0xff)
2661                 overflow = true;
2662               bfd_put_8 (abfd, voff, contents + nraddr);
2663               break;
2664
2665             case R_SH_SWITCH16:
2666               voff += adjust;
2667               if (voff < - 0x8000 || voff >= 0x8000)
2668                 overflow = true;
2669               bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
2670               break;
2671
2672             case R_SH_SWITCH32:
2673               voff += adjust;
2674               bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
2675               break;
2676
2677             case R_SH_USES:
2678               irel->r_addend += adjust;
2679               break;
2680             }
2681
2682           if (overflow)
2683             {
2684               ((*_bfd_error_handler)
2685                (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
2686                 bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
2687               bfd_set_error (bfd_error_bad_value);
2688               return false;
2689             }
2690         }
2691
2692       irel->r_offset = nraddr;
2693     }
2694
2695   /* Look through all the other sections.  If there contain any IMM32
2696      relocs against internal symbols which we are not going to adjust
2697      below, we may need to adjust the addends.  */
2698   for (o = abfd->sections; o != NULL; o = o->next)
2699     {
2700       Elf_Internal_Rela *internal_relocs;
2701       Elf_Internal_Rela *irelscan, *irelscanend;
2702       bfd_byte *ocontents;
2703
2704       if (o == sec
2705           || (o->flags & SEC_RELOC) == 0
2706           || o->reloc_count == 0)
2707         continue;
2708
2709       /* We always cache the relocs.  Perhaps, if info->keep_memory is
2710          false, we should free them, if we are permitted to, when we
2711          leave sh_coff_relax_section.  */
2712       internal_relocs = (_bfd_elf32_link_read_relocs
2713                          (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2714                           true));
2715       if (internal_relocs == NULL)
2716         return false;
2717
2718       ocontents = NULL;
2719       irelscanend = internal_relocs + o->reloc_count;
2720       for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
2721         {
2722           /* Dwarf line numbers use R_SH_SWITCH32 relocs.  */
2723           if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
2724             {
2725               bfd_vma start, stop;
2726               bfd_signed_vma voff;
2727
2728               if (ocontents == NULL)
2729                 {
2730                   if (elf_section_data (o)->this_hdr.contents != NULL)
2731                     ocontents = elf_section_data (o)->this_hdr.contents;
2732                   else
2733                     {
2734                       /* We always cache the section contents.
2735                          Perhaps, if info->keep_memory is false, we
2736                          should free them, if we are permitted to,
2737                          when we leave sh_coff_relax_section.  */
2738                       ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
2739                       if (ocontents == NULL)
2740                         return false;
2741                       if (! bfd_get_section_contents (abfd, o, ocontents,
2742                                                       (file_ptr) 0,
2743                                                       o->_raw_size))
2744                         return false;
2745                       elf_section_data (o)->this_hdr.contents = ocontents;
2746                     }
2747                 }
2748
2749               stop = irelscan->r_offset;
2750               start
2751                 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
2752
2753               /* STOP is in a different section, so it won't change.  */
2754               if (start > addr && start < toaddr)
2755                 irelscan->r_addend += count;
2756
2757               voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
2758               stop = (bfd_vma) ((bfd_signed_vma) start + voff);
2759
2760               if (start > addr
2761                   && start < toaddr
2762                   && (stop <= addr || stop >= toaddr))
2763                 bfd_put_signed_32 (abfd, (bfd_vma) voff + count,
2764                                    ocontents + irelscan->r_offset);
2765               else if (stop > addr
2766                        && stop < toaddr
2767                        && (start <= addr || start >= toaddr))
2768                 bfd_put_signed_32 (abfd, (bfd_vma) voff - count,
2769                                    ocontents + irelscan->r_offset);
2770             }
2771
2772           if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
2773             continue;
2774
2775           if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
2776             continue;
2777
2778
2779           isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2780           if (isym->st_shndx == sec_shndx
2781               && (isym->st_value <= addr
2782                   || isym->st_value >= toaddr))
2783             {
2784               bfd_vma val;
2785
2786               if (ocontents == NULL)
2787                 {
2788                   if (elf_section_data (o)->this_hdr.contents != NULL)
2789                     ocontents = elf_section_data (o)->this_hdr.contents;
2790                   else
2791                     {
2792                       /* We always cache the section contents.
2793                          Perhaps, if info->keep_memory is false, we
2794                          should free them, if we are permitted to,
2795                          when we leave sh_coff_relax_section.  */
2796                       ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
2797                       if (ocontents == NULL)
2798                         return false;
2799                       if (! bfd_get_section_contents (abfd, o, ocontents,
2800                                                       (file_ptr) 0,
2801                                                       o->_raw_size))
2802                         return false;
2803                       elf_section_data (o)->this_hdr.contents = ocontents;
2804                     }
2805                 }
2806
2807               val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
2808               val += isym->st_value;
2809               if (val > addr && val < toaddr)
2810                 bfd_put_32 (abfd, val - count,
2811                             ocontents + irelscan->r_offset);
2812             }
2813         }
2814     }
2815
2816   /* Adjust the local symbols defined in this section.  */
2817   isymend = isymbuf + symtab_hdr->sh_info;
2818   for (isym = isymbuf; isym < isymend; isym++)
2819     {
2820       if (isym->st_shndx == sec_shndx
2821           && isym->st_value > addr
2822           && isym->st_value < toaddr)
2823         isym->st_value -= count;
2824     }
2825
2826   /* Now adjust the global symbols defined in this section.  */
2827   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2828               - symtab_hdr->sh_info);
2829   sym_hashes = elf_sym_hashes (abfd);
2830   end_hashes = sym_hashes + symcount;
2831   for (; sym_hashes < end_hashes; sym_hashes++)
2832     {
2833       struct elf_link_hash_entry *sym_hash = *sym_hashes;
2834       if ((sym_hash->root.type == bfd_link_hash_defined
2835            || sym_hash->root.type == bfd_link_hash_defweak)
2836           && sym_hash->root.u.def.section == sec
2837           && sym_hash->root.u.def.value > addr
2838           && sym_hash->root.u.def.value < toaddr)
2839         {
2840           sym_hash->root.u.def.value -= count;
2841         }
2842     }
2843
2844   /* See if we can move the ALIGN reloc forward.  We have adjusted
2845      r_offset for it already.  */
2846   if (irelalign != NULL)
2847     {
2848       bfd_vma alignto, alignaddr;
2849
2850       alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
2851       alignaddr = BFD_ALIGN (irelalign->r_offset,
2852                              1 << irelalign->r_addend);
2853       if (alignto != alignaddr)
2854         {
2855           /* Tail recursion.  */
2856           return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
2857                                             (int) (alignto - alignaddr));
2858         }
2859     }
2860
2861   return true;
2862 }
2863
2864 /* Look for loads and stores which we can align to four byte
2865    boundaries.  This is like sh_align_loads in coff-sh.c.  */
2866
2867 static boolean
2868 sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
2869      bfd *abfd ATTRIBUTE_UNUSED;
2870      asection *sec;
2871      Elf_Internal_Rela *internal_relocs;
2872      bfd_byte *contents ATTRIBUTE_UNUSED;
2873      boolean *pswapped;
2874 {
2875   Elf_Internal_Rela *irel, *irelend;
2876   bfd_vma *labels = NULL;
2877   bfd_vma *label, *label_end;
2878   bfd_size_type amt;
2879
2880   *pswapped = false;
2881
2882   irelend = internal_relocs + sec->reloc_count;
2883
2884   /* Get all the addresses with labels on them.  */
2885   amt = sec->reloc_count;
2886   amt *= sizeof (bfd_vma);
2887   labels = (bfd_vma *) bfd_malloc (amt);
2888   if (labels == NULL)
2889     goto error_return;
2890   label_end = labels;
2891   for (irel = internal_relocs; irel < irelend; irel++)
2892     {
2893       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
2894         {
2895           *label_end = irel->r_offset;
2896           ++label_end;
2897         }
2898     }
2899
2900   /* Note that the assembler currently always outputs relocs in
2901      address order.  If that ever changes, this code will need to sort
2902      the label values and the relocs.  */
2903
2904   label = labels;
2905
2906   for (irel = internal_relocs; irel < irelend; irel++)
2907     {
2908       bfd_vma start, stop;
2909
2910       if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
2911         continue;
2912
2913       start = irel->r_offset;
2914
2915       for (irel++; irel < irelend; irel++)
2916         if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
2917           break;
2918       if (irel < irelend)
2919         stop = irel->r_offset;
2920       else
2921         stop = sec->_cooked_size;
2922
2923       if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
2924                                      (PTR) internal_relocs, &label,
2925                                      label_end, start, stop, pswapped))
2926         goto error_return;
2927     }
2928
2929   free (labels);
2930
2931   return true;
2932
2933  error_return:
2934   if (labels != NULL)
2935     free (labels);
2936   return false;
2937 }
2938
2939 /* Swap two SH instructions.  This is like sh_swap_insns in coff-sh.c.  */
2940
2941 static boolean
2942 sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
2943      bfd *abfd;
2944      asection *sec;
2945      PTR relocs;
2946      bfd_byte *contents;
2947      bfd_vma addr;
2948 {
2949   Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
2950   unsigned short i1, i2;
2951   Elf_Internal_Rela *irel, *irelend;
2952
2953   /* Swap the instructions themselves.  */
2954   i1 = bfd_get_16 (abfd, contents + addr);
2955   i2 = bfd_get_16 (abfd, contents + addr + 2);
2956   bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
2957   bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
2958
2959   /* Adjust all reloc addresses.  */
2960   irelend = internal_relocs + sec->reloc_count;
2961   for (irel = internal_relocs; irel < irelend; irel++)
2962     {
2963       enum elf_sh_reloc_type type;
2964       int add;
2965
2966       /* There are a few special types of relocs that we don't want to
2967          adjust.  These relocs do not apply to the instruction itself,
2968          but are only associated with the address.  */
2969       type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
2970       if (type == R_SH_ALIGN
2971           || type == R_SH_CODE
2972           || type == R_SH_DATA
2973           || type == R_SH_LABEL)
2974         continue;
2975
2976       /* If an R_SH_USES reloc points to one of the addresses being
2977          swapped, we must adjust it.  It would be incorrect to do this
2978          for a jump, though, since we want to execute both
2979          instructions after the jump.  (We have avoided swapping
2980          around a label, so the jump will not wind up executing an
2981          instruction it shouldn't).  */
2982       if (type == R_SH_USES)
2983         {
2984           bfd_vma off;
2985
2986           off = irel->r_offset + 4 + irel->r_addend;
2987           if (off == addr)
2988             irel->r_offset += 2;
2989           else if (off == addr + 2)
2990             irel->r_offset -= 2;
2991         }
2992
2993       if (irel->r_offset == addr)
2994         {
2995           irel->r_offset += 2;
2996           add = -2;
2997         }
2998       else if (irel->r_offset == addr + 2)
2999         {
3000           irel->r_offset -= 2;
3001           add = 2;
3002         }
3003       else
3004         add = 0;
3005
3006       if (add != 0)
3007         {
3008           bfd_byte *loc;
3009           unsigned short insn, oinsn;
3010           boolean overflow;
3011
3012           loc = contents + irel->r_offset;
3013           overflow = false;
3014           switch (type)
3015             {
3016             default:
3017               break;
3018
3019             case R_SH_DIR8WPN:
3020             case R_SH_DIR8WPZ:
3021               insn = bfd_get_16 (abfd, loc);
3022               oinsn = insn;
3023               insn += add / 2;
3024               if ((oinsn & 0xff00) != (insn & 0xff00))
3025                 overflow = true;
3026               bfd_put_16 (abfd, (bfd_vma) insn, loc);
3027               break;
3028
3029             case R_SH_IND12W:
3030               insn = bfd_get_16 (abfd, loc);
3031               oinsn = insn;
3032               insn += add / 2;
3033               if ((oinsn & 0xf000) != (insn & 0xf000))
3034                 overflow = true;
3035               bfd_put_16 (abfd, (bfd_vma) insn, loc);
3036               break;
3037
3038             case R_SH_DIR8WPL:
3039               /* This reloc ignores the least significant 3 bits of
3040                  the program counter before adding in the offset.
3041                  This means that if ADDR is at an even address, the
3042                  swap will not affect the offset.  If ADDR is an at an
3043                  odd address, then the instruction will be crossing a
3044                  four byte boundary, and must be adjusted.  */
3045               if ((addr & 3) != 0)
3046                 {
3047                   insn = bfd_get_16 (abfd, loc);
3048                   oinsn = insn;
3049                   insn += add / 2;
3050                   if ((oinsn & 0xff00) != (insn & 0xff00))
3051                     overflow = true;
3052                   bfd_put_16 (abfd, (bfd_vma) insn, loc);
3053                 }
3054
3055               break;
3056             }
3057
3058           if (overflow)
3059             {
3060               ((*_bfd_error_handler)
3061                (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
3062                 bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
3063               bfd_set_error (bfd_error_bad_value);
3064               return false;
3065             }
3066         }
3067     }
3068
3069   return true;
3070 }
3071 \f
3072 #ifdef INCLUDE_SHMEDIA
3073
3074 /* The size in bytes of an entry in the procedure linkage table.  */
3075
3076 #define PLT_ENTRY_SIZE 64
3077
3078 /* First entry in an absolute procedure linkage table look like this.  */
3079
3080 static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3081 {
3082   0xcc, 0x00, 0x01, 0x10, /* movi  .got.plt >> 16, r17 */
3083   0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
3084   0x89, 0x10, 0x09, 0x90, /* ld.l  r17, 8, r25 */
3085   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3086   0x89, 0x10, 0x05, 0x10, /* ld.l  r17, 4, r17 */
3087   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3088   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3089   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3090   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3091   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3092   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3093   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3094   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3095   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3096   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3097   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3098 };
3099
3100 static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3101 {
3102   0x10, 0x01, 0x00, 0xcc, /* movi  .got.plt >> 16, r17 */
3103   0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
3104   0x90, 0x09, 0x10, 0x89, /* ld.l  r17, 8, r25 */
3105   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3106   0x10, 0x05, 0x10, 0x89, /* ld.l  r17, 4, r17 */
3107   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3108   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3109   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3110   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3111   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3112   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3113   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3114   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3115   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3116   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3117   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3118 };
3119
3120 /* Sebsequent entries in an absolute procedure linkage table look like
3121    this.  */
3122
3123 static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3124 {
3125   0xcc, 0x00, 0x01, 0x90, /* movi  nameN-in-GOT >> 16, r25 */
3126   0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
3127   0x89, 0x90, 0x01, 0x90, /* ld.l  r25, 0, r25 */
3128   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3129   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3130   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3131   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3132   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3133   0xcc, 0x00, 0x01, 0x90, /* movi  .PLT0 >> 16, r25 */
3134   0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
3135   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3136   0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
3137   0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3138   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3139   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3140   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3141 };
3142
3143 static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3144 {
3145   0x90, 0x01, 0x00, 0xcc, /* movi  nameN-in-GOT >> 16, r25 */
3146   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
3147   0x90, 0x01, 0x90, 0x89, /* ld.l  r25, 0, r25 */
3148   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3149   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3150   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3151   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3152   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3153   0x90, 0x01, 0x00, 0xcc, /* movi  .PLT0 >> 16, r25 */
3154   0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
3155   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3156   0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
3157   0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3158   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3159   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3160   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3161 };
3162
3163 /* Entries in a PIC procedure linkage table look like this.  */
3164
3165 static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3166 {
3167   0xcc, 0x00, 0x01, 0x90, /* movi  nameN@GOT >> 16, r25 */
3168   0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
3169   0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
3170   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3171   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3172   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3173   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3174   0x6f, 0xf0, 0xff, 0xf0, /* nop */
3175   0xce, 0x00, 0x01, 0x10, /* movi  -GOT_BIAS, r17 */
3176   0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
3177   0x89, 0x10, 0x09, 0x90, /* ld.l  r17, 8, r25 */
3178   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3179   0x89, 0x10, 0x05, 0x10, /* ld.l  r17, 4, r17 */
3180   0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
3181   0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3182   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3183 };
3184
3185 static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3186 {
3187   0x90, 0x01, 0x00, 0xcc, /* movi  nameN@GOT >> 16, r25 */
3188   0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
3189   0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
3190   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3191   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3192   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3193   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3194   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3195   0x10, 0x01, 0x00, 0xce, /* movi  -GOT_BIAS, r17 */
3196   0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
3197   0x90, 0x09, 0x10, 0x89, /* ld.l  r17, 8, r25 */
3198   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3199   0x10, 0x05, 0x10, 0x89, /* ld.l  r17, 4, r17 */
3200   0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
3201   0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3202   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3203 };
3204
3205 static const bfd_byte *elf_sh_plt0_entry;
3206 static const bfd_byte *elf_sh_plt_entry;
3207 static const bfd_byte *elf_sh_pic_plt_entry;
3208
3209 /* Return size of a PLT entry.  */
3210 #define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
3211
3212 /* Return offset of the PLT0 address in an absolute PLT entry.  */
3213 #define elf_sh_plt_plt0_offset(info) 32
3214
3215 /* Return offset of the linker in PLT0 entry.  */
3216 #define elf_sh_plt0_gotplt_offset(info) 0
3217
3218 /* Return offset of the trampoline in PLT entry */
3219 #define elf_sh_plt_temp_offset(info) 33 /* Add one because it's SHmedia.  */
3220
3221 /* Return offset of the symbol in PLT entry.  */
3222 #define elf_sh_plt_symbol_offset(info) 0
3223
3224 /* Return offset of the relocation in PLT entry.  */
3225 #define elf_sh_plt_reloc_offset(info) (info->shared ? 52 : 44)
3226
3227 inline static void
3228 movi_shori_putval (output_bfd, value, addr)
3229      bfd *output_bfd;
3230      unsigned long value;
3231      char *addr;
3232 {
3233   bfd_put_32 (output_bfd,
3234               bfd_get_32 (output_bfd, addr)
3235               | ((value >> 6) & 0x3fffc00),
3236               addr);
3237   bfd_put_32 (output_bfd,
3238               bfd_get_32 (output_bfd, addr + 4)
3239               | ((value << 10) & 0x3fffc00),
3240               addr + 4);
3241 }
3242
3243 #else
3244 /* The size in bytes of an entry in the procedure linkage table.  */
3245
3246 #define PLT_ENTRY_SIZE 28
3247
3248 /* First entry in an absolute procedure linkage table look like this.  */
3249
3250 #if 1
3251 /* Note - this code has been "optimised" not to use r2.  r2 is used by
3252    GCC to return the address of large strutcures, so it should not be
3253    corrupted here.  This does mean however, that this PLT does not conform
3254    to the SH PIC ABI.  That spec says that r0 contains the type of the PLT
3255    and r2 contains the GOT id.  This version stores the GOT id in r0 and
3256    ignores the type.  Loaders can easily detect this difference however,
3257    since the type will always be 0 or 8, and the GOT ids will always be
3258    greater than or equal to 12.  */
3259 static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3260 {
3261   0xd0, 0x05,   /* mov.l 2f,r0 */
3262   0x60, 0x02,   /* mov.l @r0,r0 */
3263   0x2f, 0x06,   /* mov.l r0,@-r15 */
3264   0xd0, 0x03,   /* mov.l 1f,r0 */
3265   0x60, 0x02,   /* mov.l @r0,r0 */
3266   0x40, 0x2b,   /* jmp @r0 */
3267   0x60, 0xf6,   /*  mov.l @r15+,r0 */
3268   0x00, 0x09,   /* nop */
3269   0x00, 0x09,   /* nop */
3270   0x00, 0x09,   /* nop */
3271   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
3272   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
3273 };
3274
3275 static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3276 {
3277   0x05, 0xd0,   /* mov.l 2f,r0 */
3278   0x02, 0x60,   /* mov.l @r0,r0 */
3279   0x06, 0x2f,   /* mov.l r0,@-r15 */
3280   0x03, 0xd0,   /* mov.l 1f,r0 */
3281   0x02, 0x60,   /* mov.l @r0,r0 */
3282   0x2b, 0x40,   /* jmp @r0 */
3283   0xf6, 0x60,   /*  mov.l @r15+,r0 */
3284   0x09, 0x00,   /* nop */
3285   0x09, 0x00,   /* nop */
3286   0x09, 0x00,   /* nop */
3287   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
3288   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
3289 };
3290
3291 /* Sebsequent entries in an absolute procedure linkage table look like
3292    this.  */
3293
3294 static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3295 {
3296   0xd0, 0x04,   /* mov.l 1f,r0 */
3297   0x60, 0x02,   /* mov.l @r0,r0 */
3298   0xd1, 0x02,   /* mov.l 0f,r1 */
3299   0x40, 0x2b,   /* jmp @r0 */
3300   0x60, 0x13,   /*  mov r1,r0 */
3301   0xd1, 0x03,   /* mov.l 2f,r1 */
3302   0x40, 0x2b,   /* jmp @r0 */
3303   0x00, 0x09,   /* nop */
3304   0, 0, 0, 0,   /* 0: replaced with address of .PLT0.  */
3305   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
3306   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
3307 };
3308
3309 static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3310 {
3311   0x04, 0xd0,   /* mov.l 1f,r0 */
3312   0x02, 0x60,   /* mov.l @r0,r0 */
3313   0x02, 0xd1,   /* mov.l 0f,r1 */
3314   0x2b, 0x40,   /* jmp @r0 */
3315   0x13, 0x60,   /*  mov r1,r0 */
3316   0x03, 0xd1,   /* mov.l 2f,r1 */
3317   0x2b, 0x40,   /* jmp @r0 */
3318   0x09, 0x00,   /*  nop */
3319   0, 0, 0, 0,   /* 0: replaced with address of .PLT0.  */
3320   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
3321   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
3322 };
3323
3324 /* Entries in a PIC procedure linkage table look like this.  */
3325
3326 static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3327 {
3328   0xd0, 0x04,   /* mov.l 1f,r0 */
3329   0x00, 0xce,   /* mov.l @(r0,r12),r0 */
3330   0x40, 0x2b,   /* jmp @r0 */
3331   0x00, 0x09,   /*  nop */
3332   0x50, 0xc2,   /* mov.l @(8,r12),r0 */
3333   0xd1, 0x03,   /* mov.l 2f,r1 */
3334   0x40, 0x2b,   /* jmp @r0 */
3335   0x50, 0xc1,   /*  mov.l @(4,r12),r0 */
3336   0x00, 0x09,   /* nop */
3337   0x00, 0x09,   /* nop */
3338   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
3339   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
3340 };
3341
3342 static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3343 {
3344   0x04, 0xd0,   /* mov.l 1f,r0 */
3345   0xce, 0x00,   /* mov.l @(r0,r12),r0 */
3346   0x2b, 0x40,   /* jmp @r0 */
3347   0x09, 0x00,   /*  nop */
3348   0xc2, 0x50,   /* mov.l @(8,r12),r0 */
3349   0x03, 0xd1,   /* mov.l 2f,r1 */
3350   0x2b, 0x40,   /* jmp @r0 */
3351   0xc1, 0x50,   /*  mov.l @(4,r12),r0 */
3352   0x09, 0x00,   /*  nop */
3353   0x09, 0x00,   /* nop */
3354   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
3355   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
3356 };
3357
3358 #else /* These are the old style PLT entries.  */
3359 static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3360 {
3361   0xd0, 0x04,   /* mov.l 1f,r0 */
3362   0xd2, 0x05,   /* mov.l 2f,r2 */
3363   0x60, 0x02,   /* mov.l @r0,r0 */
3364   0x62, 0x22,   /* mov.l @r2,r2 */
3365   0x40, 0x2b,   /* jmp @r0 */
3366   0xe0, 0x00,   /*  mov #0,r0 */
3367   0x00, 0x09,   /* nop */
3368   0x00, 0x09,   /* nop */
3369   0x00, 0x09,   /* nop */
3370   0x00, 0x09,   /* nop */
3371   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
3372   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
3373 };
3374
3375 static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3376 {
3377   0x04, 0xd0,   /* mov.l 1f,r0 */
3378   0x05, 0xd2,   /* mov.l 2f,r2 */
3379   0x02, 0x60,   /* mov.l @r0,r0 */
3380   0x22, 0x62,   /* mov.l @r2,r2 */
3381   0x2b, 0x40,   /* jmp @r0 */
3382   0x00, 0xe0,   /*  mov #0,r0 */
3383   0x09, 0x00,   /* nop */
3384   0x09, 0x00,   /* nop */
3385   0x09, 0x00,   /* nop */
3386   0x09, 0x00,   /* nop */
3387   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
3388   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
3389 };
3390
3391 /* Sebsequent entries in an absolute procedure linkage table look like
3392    this.  */
3393
3394 static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3395 {
3396   0xd0, 0x04,   /* mov.l 1f,r0 */
3397   0x60, 0x02,   /* mov.l @r0,r0 */
3398   0xd2, 0x02,   /* mov.l 0f,r2 */
3399   0x40, 0x2b,   /* jmp @r0 */
3400   0x60, 0x23,   /*  mov r2,r0 */
3401   0xd1, 0x03,   /* mov.l 2f,r1 */
3402   0x40, 0x2b,   /* jmp @r0 */
3403   0x00, 0x09,   /* nop */
3404   0, 0, 0, 0,   /* 0: replaced with address of .PLT0.  */
3405   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
3406   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
3407 };
3408
3409 static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3410 {
3411   0x04, 0xd0,   /* mov.l 1f,r0 */
3412   0x02, 0x60,   /* mov.l @r0,r0 */
3413   0x02, 0xd2,   /* mov.l 0f,r2 */
3414   0x2b, 0x40,   /* jmp @r0 */
3415   0x23, 0x60,   /*  mov r2,r0 */
3416   0x03, 0xd1,   /* mov.l 2f,r1 */
3417   0x2b, 0x40,   /* jmp @r0 */
3418   0x09, 0x00,   /*  nop */
3419   0, 0, 0, 0,   /* 0: replaced with address of .PLT.  */
3420   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
3421   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
3422 };
3423
3424 /* Entries in a PIC procedure linkage table look like this.  */
3425
3426 static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3427 {
3428   0xd0, 0x04,   /* mov.l 1f,r0 */
3429   0x00, 0xce,   /* mov.l @(r0,r12),r0 */
3430   0x40, 0x2b,   /* jmp @r0 */
3431   0x00, 0x09,   /*  nop */
3432   0x50, 0xc2,   /* 0: mov.l @(8,r12),r0 */
3433   0x52, 0xc1,   /* 1: mov.l @(4,r12),r2 */
3434   0xd1, 0x02,   /* mov.l 2f,r1 */
3435   0x40, 0x2b,   /* jmp @r0 */
3436   0xe0, 0x00,   /*  mov #0,r0 ! shows the type of PLT.  */
3437   0x00, 0x09,   /* nop */
3438   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
3439   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
3440 };
3441
3442 static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3443 {
3444   0x04, 0xd0,   /* mov.l 1f,r0 */
3445   0xce, 0x00,   /* mov.l @(r0,r12),r0 */
3446   0x2b, 0x40,   /* jmp @r0 */
3447   0x09, 0x00,   /*  nop */
3448   0xc2, 0x50,   /* 0: mov.l @(8,r12),r0 */
3449   0xc1, 0x52,   /* 1: mov.l @(4,r12),r2 */
3450   0x02, 0xd1,   /* mov.l 2f,r1 */
3451   0x2b, 0x40,   /* jmp @r0 */
3452   0x00, 0xe0,   /*  mov #0,r0 ! shows the type of PLT.  */
3453   0x09, 0x00,   /* nop */
3454   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
3455   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
3456 };
3457 #endif /* old style PLT entries.  */
3458
3459 static const bfd_byte *elf_sh_plt0_entry;
3460 static const bfd_byte *elf_sh_plt_entry;
3461 static const bfd_byte *elf_sh_pic_plt_entry;
3462
3463 /* Return size of a PLT entry.  */
3464 #define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
3465
3466 /* Return offset of the PLT0 address in an absolute PLT entry.  */
3467 #define elf_sh_plt_plt0_offset(info) 16
3468
3469 /* Return offset of the linker in PLT0 entry.  */
3470 #define elf_sh_plt0_linker_offset(info) 20
3471
3472 /* Return offset of the GOT id in PLT0 entry.  */
3473 #define elf_sh_plt0_gotid_offset(info) 24
3474
3475 /* Return offset of the tempoline in PLT entry */
3476 #define elf_sh_plt_temp_offset(info) 8
3477
3478 /* Return offset of the symbol in PLT entry.  */
3479 #define elf_sh_plt_symbol_offset(info) 20
3480
3481 /* Return offset of the relocation in PLT entry.  */
3482 #define elf_sh_plt_reloc_offset(info) 24
3483 #endif
3484
3485 /* The sh linker needs to keep track of the number of relocs that it
3486    decides to copy as dynamic relocs in check_relocs for each symbol.
3487    This is so that it can later discard them if they are found to be
3488    unnecessary.  We store the information in a field extending the
3489    regular ELF linker hash table.  */
3490
3491 struct elf_sh_dyn_relocs
3492 {
3493   struct elf_sh_dyn_relocs *next;
3494
3495   /* The input section of the reloc.  */
3496   asection *sec;
3497
3498   /* Total number of relocs copied for the input section.  */
3499   bfd_size_type count;
3500
3501   /* Number of pc-relative relocs copied for the input section.  */
3502   bfd_size_type pc_count;
3503 };
3504
3505 /* sh ELF linker hash entry.  */
3506
3507 struct elf_sh_link_hash_entry
3508 {
3509   struct elf_link_hash_entry root;
3510
3511 #ifdef INCLUDE_SHMEDIA
3512   union
3513   {
3514     bfd_signed_vma refcount;
3515     bfd_vma offset;
3516   } datalabel_got;
3517 #endif
3518
3519   /* Track dynamic relocs copied for this symbol.  */
3520   struct elf_sh_dyn_relocs *dyn_relocs;
3521
3522   bfd_signed_vma gotplt_refcount;
3523
3524   enum {
3525     GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE
3526   } tls_type;
3527
3528   /* If true, R_SH_TLS_TPOFF32 relocation is generated.  */
3529   boolean tls_tpoff32;
3530 };
3531
3532 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
3533
3534 struct sh_elf_obj_tdata
3535 {
3536   struct elf_obj_tdata root;
3537
3538   /* tls_type for each local got entry.  */
3539   char *local_got_tls_type;
3540 };
3541
3542 #define sh_elf_tdata(abfd) \
3543   ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
3544
3545 #define sh_elf_local_got_tls_type(abfd) \
3546   (sh_elf_tdata (abfd)->local_got_tls_type)
3547
3548 /* Override the generic function because we need to store sh_elf_obj_tdata
3549    as the specific tdata.  */
3550
3551 static boolean
3552 sh_elf_mkobject (abfd)
3553      bfd *abfd;
3554 {
3555   bfd_size_type amt = sizeof (struct sh_elf_obj_tdata);
3556   abfd->tdata.any = bfd_zalloc (abfd, amt);
3557   if (abfd->tdata.any == NULL)
3558     return false;
3559   return true;
3560 }
3561
3562 /* sh ELF linker hash table.  */
3563
3564 struct elf_sh_link_hash_table
3565 {
3566   struct elf_link_hash_table root;
3567
3568   /* Short-cuts to get to dynamic linker sections.  */
3569   asection *sgot;
3570   asection *sgotplt;
3571   asection *srelgot;
3572   asection *splt;
3573   asection *srelplt;
3574   asection *sdynbss;
3575   asection *srelbss;
3576
3577   /* Small local sym to section mapping cache.  */
3578   struct sym_sec_cache sym_sec;
3579
3580   /* A counter or offset to track a TLS got entry.  */
3581   union
3582     {
3583       bfd_signed_vma refcount;
3584       bfd_vma offset;
3585     } tls_ldm_got;
3586 };
3587
3588 /* Traverse an sh ELF linker hash table.  */
3589
3590 #define sh_elf_link_hash_traverse(table, func, info)                    \
3591   (elf_link_hash_traverse                                               \
3592    (&(table)->root,                                                     \
3593     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
3594     (info)))
3595
3596 /* Get the sh ELF linker hash table from a link_info structure.  */
3597
3598 #define sh_elf_hash_table(p) \
3599   ((struct elf_sh_link_hash_table *) ((p)->hash))
3600
3601 /* Create an entry in an sh ELF linker hash table.  */
3602
3603 static struct bfd_hash_entry *
3604 sh_elf_link_hash_newfunc (entry, table, string)
3605      struct bfd_hash_entry *entry;
3606      struct bfd_hash_table *table;
3607      const char *string;
3608 {
3609   struct elf_sh_link_hash_entry *ret =
3610     (struct elf_sh_link_hash_entry *) entry;
3611
3612   /* Allocate the structure if it has not already been allocated by a
3613      subclass.  */
3614   if (ret == (struct elf_sh_link_hash_entry *) NULL)
3615     ret = ((struct elf_sh_link_hash_entry *)
3616            bfd_hash_allocate (table,
3617                               sizeof (struct elf_sh_link_hash_entry)));
3618   if (ret == (struct elf_sh_link_hash_entry *) NULL)
3619     return (struct bfd_hash_entry *) ret;
3620
3621   /* Call the allocation method of the superclass.  */
3622   ret = ((struct elf_sh_link_hash_entry *)
3623          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3624                                      table, string));
3625   if (ret != (struct elf_sh_link_hash_entry *) NULL)
3626     {
3627       ret->dyn_relocs = NULL;
3628       ret->gotplt_refcount = 0;
3629 #ifdef INCLUDE_SHMEDIA
3630       ret->datalabel_got.refcount = ret->root.got.refcount;
3631 #endif
3632       ret->tls_type = GOT_UNKNOWN;
3633       ret->tls_tpoff32 = false;
3634     }
3635
3636   return (struct bfd_hash_entry *) ret;
3637 }
3638
3639 /* Create an sh ELF linker hash table.  */
3640
3641 static struct bfd_link_hash_table *
3642 sh_elf_link_hash_table_create (abfd)
3643      bfd *abfd;
3644 {
3645   struct elf_sh_link_hash_table *ret;
3646   bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
3647
3648   ret = (struct elf_sh_link_hash_table *) bfd_malloc (amt);
3649   if (ret == (struct elf_sh_link_hash_table *) NULL)
3650     return NULL;
3651
3652   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
3653                                        sh_elf_link_hash_newfunc))
3654     {
3655       free (ret);
3656       return NULL;
3657     }
3658
3659   ret->sgot = NULL;
3660   ret->sgotplt = NULL;
3661   ret->srelgot = NULL;
3662   ret->splt = NULL;
3663   ret->srelplt = NULL;
3664   ret->sdynbss = NULL;
3665   ret->srelbss = NULL;
3666   ret->sym_sec.abfd = NULL;
3667   ret->tls_ldm_got.refcount = 0;
3668
3669   return &ret->root.root;
3670 }
3671
3672 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3673    shortcuts to them in our hash table.  */
3674
3675 static boolean
3676 create_got_section (dynobj, info)
3677      bfd *dynobj;
3678      struct bfd_link_info *info;
3679 {
3680   struct elf_sh_link_hash_table *htab;
3681
3682   if (! _bfd_elf_create_got_section (dynobj, info))
3683     return false;
3684
3685   htab = sh_elf_hash_table (info);
3686   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
3687   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3688   if (! htab->sgot || ! htab->sgotplt)
3689     abort ();
3690
3691   htab->srelgot = bfd_make_section (dynobj, ".rela.got");
3692   if (htab->srelgot == NULL
3693       || ! bfd_set_section_flags (dynobj, htab->srelgot,
3694                                   (SEC_ALLOC
3695                                    | SEC_LOAD
3696                                    | SEC_HAS_CONTENTS
3697                                    | SEC_IN_MEMORY
3698                                    | SEC_LINKER_CREATED
3699                                    | SEC_READONLY))
3700       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
3701     return false;
3702   return true;
3703 }
3704
3705 /* Create dynamic sections when linking against a dynamic object.  */
3706
3707 static boolean
3708 sh_elf_create_dynamic_sections (abfd, info)
3709      bfd *abfd;
3710      struct bfd_link_info *info;
3711 {
3712   struct elf_sh_link_hash_table *htab;
3713   flagword flags, pltflags;
3714   register asection *s;
3715   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3716   int ptralign = 0;
3717
3718   switch (bed->s->arch_size)
3719     {
3720     case 32:
3721       ptralign = 2;
3722       break;
3723
3724     case 64:
3725       ptralign = 3;
3726       break;
3727
3728     default:
3729       bfd_set_error (bfd_error_bad_value);
3730       return false;
3731     }
3732
3733   htab = sh_elf_hash_table (info);
3734
3735   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3736      .rel[a].bss sections.  */
3737
3738   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3739            | SEC_LINKER_CREATED);
3740
3741   pltflags = flags;
3742   pltflags |= SEC_CODE;
3743   if (bed->plt_not_loaded)
3744     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3745   if (bed->plt_readonly)
3746     pltflags |= SEC_READONLY;
3747
3748   s = bfd_make_section (abfd, ".plt");
3749   htab->splt = s;
3750   if (s == NULL
3751       || ! bfd_set_section_flags (abfd, s, pltflags)
3752       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3753     return false;
3754
3755   if (bed->want_plt_sym)
3756     {
3757       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3758          .plt section.  */
3759       struct elf_link_hash_entry *h;
3760       struct bfd_link_hash_entry *bh = NULL;
3761
3762       if (! (_bfd_generic_link_add_one_symbol
3763              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3764               (bfd_vma) 0, (const char *) NULL, false,
3765               get_elf_backend_data (abfd)->collect, &bh)))
3766         return false;
3767
3768       h = (struct elf_link_hash_entry *) bh;
3769       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3770       h->type = STT_OBJECT;
3771
3772       if (info->shared
3773           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
3774         return false;
3775     }
3776
3777   s = bfd_make_section (abfd,
3778                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3779   htab->srelplt = s;
3780   if (s == NULL
3781       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3782       || ! bfd_set_section_alignment (abfd, s, ptralign))
3783     return false;
3784
3785   if (! create_got_section (abfd, info))
3786     return false;
3787
3788   {
3789     const char *secname;
3790     char *relname;
3791     flagword secflags;
3792     asection *sec;
3793
3794     for (sec = abfd->sections; sec; sec = sec->next)
3795       {
3796         secflags = bfd_get_section_flags (abfd, sec);
3797         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3798             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3799           continue;
3800         secname = bfd_get_section_name (abfd, sec);
3801         relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3802         strcpy (relname, ".rela");
3803         strcat (relname, secname);
3804         s = bfd_make_section (abfd, relname);
3805         if (s == NULL
3806             || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3807             || ! bfd_set_section_alignment (abfd, s, ptralign))
3808           return false;
3809       }
3810   }
3811
3812   if (bed->want_dynbss)
3813     {
3814       /* The .dynbss section is a place to put symbols which are defined
3815          by dynamic objects, are referenced by regular objects, and are
3816          not functions.  We must allocate space for them in the process
3817          image and use a R_*_COPY reloc to tell the dynamic linker to
3818          initialize them at run time.  The linker script puts the .dynbss
3819          section into the .bss section of the final image.  */
3820       s = bfd_make_section (abfd, ".dynbss");
3821       htab->sdynbss = s;
3822       if (s == NULL
3823           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
3824         return false;
3825
3826       /* The .rel[a].bss section holds copy relocs.  This section is not
3827          normally needed.  We need to create it here, though, so that the
3828          linker will map it to an output section.  We can't just create it
3829          only if we need it, because we will not know whether we need it
3830          until we have seen all the input files, and the first time the
3831          main linker code calls BFD after examining all the input files
3832          (size_dynamic_sections) the input sections have already been
3833          mapped to the output sections.  If the section turns out not to
3834          be needed, we can discard it later.  We will never need this
3835          section when generating a shared object, since they do not use
3836          copy relocs.  */
3837       if (! info->shared)
3838         {
3839           s = bfd_make_section (abfd,
3840                                 (bed->default_use_rela_p
3841                                  ? ".rela.bss" : ".rel.bss"));
3842           htab->srelbss = s;
3843           if (s == NULL
3844               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3845               || ! bfd_set_section_alignment (abfd, s, ptralign))
3846             return false;
3847         }
3848     }
3849
3850   return true;
3851 }
3852 \f
3853 /* Adjust a symbol defined by a dynamic object and referenced by a
3854    regular object.  The current definition is in some section of the
3855    dynamic object, but we're not including those sections.  We have to
3856    change the definition to something the rest of the link can
3857    understand.  */
3858
3859 static boolean
3860 sh_elf_adjust_dynamic_symbol (info, h)
3861      struct bfd_link_info *info;
3862      struct elf_link_hash_entry *h;
3863 {
3864   struct elf_sh_link_hash_table *htab;
3865   struct elf_sh_link_hash_entry *eh;
3866   struct elf_sh_dyn_relocs *p;
3867   bfd *dynobj;
3868   asection *s;
3869   unsigned int power_of_two;
3870
3871   dynobj = elf_hash_table (info)->dynobj;
3872
3873   /* Make sure we know what is going on here.  */
3874   BFD_ASSERT (dynobj != NULL
3875               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
3876                   || h->weakdef != NULL
3877                   || ((h->elf_link_hash_flags
3878                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3879                       && (h->elf_link_hash_flags
3880                           & ELF_LINK_HASH_REF_REGULAR) != 0
3881                       && (h->elf_link_hash_flags
3882                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
3883
3884   /* If this is a function, put it in the procedure linkage table.  We
3885      will fill in the contents of the procedure linkage table later,
3886      when we know the address of the .got section.  */
3887   if (h->type == STT_FUNC
3888       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
3889     {
3890       if (h->plt.refcount <= 0
3891           || (! info->shared
3892               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3893               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
3894               && h->root.type != bfd_link_hash_undefweak
3895               && h->root.type != bfd_link_hash_undefined))
3896         {
3897           /* This case can occur if we saw a PLT reloc in an input
3898              file, but the symbol was never referred to by a dynamic
3899              object.  In such a case, we don't actually need to build
3900              a procedure linkage table, and we can just do a REL32
3901              reloc instead.  */
3902           h->plt.offset = (bfd_vma) -1;
3903           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3904         }
3905
3906       return true;
3907     }
3908   else
3909     h->plt.offset = (bfd_vma) -1;
3910
3911   /* If this is a weak symbol, and there is a real definition, the
3912      processor independent code will have arranged for us to see the
3913      real definition first, and we can just use the same value.  */
3914   if (h->weakdef != NULL)
3915     {
3916       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3917                   || h->weakdef->root.type == bfd_link_hash_defweak);
3918       h->root.u.def.section = h->weakdef->root.u.def.section;
3919       h->root.u.def.value = h->weakdef->root.u.def.value;
3920       return true;
3921     }
3922
3923   /* This is a reference to a symbol defined by a dynamic object which
3924      is not a function.  */
3925
3926   /* If we are creating a shared library, we must presume that the
3927      only references to the symbol are via the global offset table.
3928      For such cases we need not do anything here; the relocations will
3929      be handled correctly by relocate_section.  */
3930   if (info->shared)
3931     return true;
3932
3933   /* If there are no references to this symbol that do not use the
3934      GOT, we don't need to generate a copy reloc.  */
3935   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
3936     return true;
3937
3938   /* If -z nocopyreloc was given, we won't generate them either.  */
3939   if (info->nocopyreloc)
3940     {
3941       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
3942       return true;
3943     }
3944
3945   eh = (struct elf_sh_link_hash_entry *) h;
3946   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3947     {
3948       s = p->sec->output_section;
3949       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3950         break;
3951     }
3952
3953   /* If we didn't find any dynamic relocs in sections which needs the
3954      copy reloc, then we'll be keeping the dynamic relocs and avoiding
3955      the copy reloc.  */
3956   if (p == NULL)
3957     {
3958       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
3959       return true;
3960     }
3961
3962   /* We must allocate the symbol in our .dynbss section, which will
3963      become part of the .bss section of the executable.  There will be
3964      an entry for this symbol in the .dynsym section.  The dynamic
3965      object will contain position independent code, so all references
3966      from the dynamic object to this symbol will go through the global
3967      offset table.  The dynamic linker will use the .dynsym entry to
3968      determine the address it must put in the global offset table, so
3969      both the dynamic object and the regular object will refer to the
3970      same memory location for the variable.  */
3971
3972   htab = sh_elf_hash_table (info);
3973   s = htab->sdynbss;
3974   BFD_ASSERT (s != NULL);
3975
3976   /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
3977      copy the initial value out of the dynamic object and into the
3978      runtime process image.  We need to remember the offset into the
3979      .rela.bss section we are going to use.  */
3980   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3981     {
3982       asection *srel;
3983
3984       srel = htab->srelbss;
3985       BFD_ASSERT (srel != NULL);
3986       srel->_raw_size += sizeof (Elf32_External_Rela);
3987       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3988     }
3989
3990   /* We need to figure out the alignment required for this symbol.  I
3991      have no idea how ELF linkers handle this.  */
3992   power_of_two = bfd_log2 (h->size);
3993   if (power_of_two > 3)
3994     power_of_two = 3;
3995
3996   /* Apply the required alignment.  */
3997   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
3998   if (power_of_two > bfd_get_section_alignment (dynobj, s))
3999     {
4000       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
4001         return false;
4002     }
4003
4004   /* Define the symbol as being at this point in the section.  */
4005   h->root.u.def.section = s;
4006   h->root.u.def.value = s->_raw_size;
4007
4008   /* Increment the section size to make room for the symbol.  */
4009   s->_raw_size += h->size;
4010
4011   return true;
4012 }
4013
4014 /* This is the condition under which sh_elf_finish_dynamic_symbol
4015    will be called from elflink.h.  If elflink.h doesn't call our
4016    finish_dynamic_symbol routine, we'll need to do something about
4017    initializing any .plt and .got entries in sh_elf_relocate_section.  */
4018 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
4019   ((DYN)                                                                \
4020    && ((INFO)->shared                                                   \
4021        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
4022    && ((H)->dynindx != -1                                               \
4023        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
4024
4025 /* Allocate space in .plt, .got and associated reloc sections for
4026    dynamic relocs.  */
4027
4028 static boolean
4029 allocate_dynrelocs (h, inf)
4030      struct elf_link_hash_entry *h;
4031      PTR inf;
4032 {
4033   struct bfd_link_info *info;
4034   struct elf_sh_link_hash_table *htab;
4035   struct elf_sh_link_hash_entry *eh;
4036   struct elf_sh_dyn_relocs *p;
4037
4038   if (h->root.type == bfd_link_hash_indirect)
4039     return true;
4040
4041   if (h->root.type == bfd_link_hash_warning)
4042     /* When warning symbols are created, they **replace** the "real"
4043        entry in the hash table, thus we never get to see the real
4044        symbol in a hash traversal.  So look at it now.  */
4045     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4046
4047   info = (struct bfd_link_info *) inf;
4048   htab = sh_elf_hash_table (info);
4049
4050   eh = (struct elf_sh_link_hash_entry *) h;
4051   if ((h->got.refcount > 0
4052       || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
4053       && eh->gotplt_refcount > 0)
4054     {
4055       /* The symbol has been forced local, or we have some direct got refs,
4056          so treat all the gotplt refs as got refs. */
4057       h->got.refcount += eh->gotplt_refcount;
4058       if (h->plt.refcount >= eh->gotplt_refcount)
4059         h->plt.refcount -= eh->gotplt_refcount;
4060     }
4061
4062   if (htab->root.dynamic_sections_created
4063       && h->plt.refcount > 0)
4064     {
4065       /* Make sure this symbol is output as a dynamic symbol.
4066          Undefined weak syms won't yet be marked as dynamic.  */
4067       if (h->dynindx == -1
4068           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4069         {
4070           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4071             return false;
4072         }
4073
4074       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
4075         {
4076           asection *s = htab->splt;
4077
4078           /* If this is the first .plt entry, make room for the special
4079              first entry.  */
4080           if (s->_raw_size == 0)
4081             s->_raw_size += PLT_ENTRY_SIZE;
4082
4083           h->plt.offset = s->_raw_size;
4084
4085           /* If this symbol is not defined in a regular file, and we are
4086              not generating a shared library, then set the symbol to this
4087              location in the .plt.  This is required to make function
4088              pointers compare as equal between the normal executable and
4089              the shared library.  */
4090           if (! info->shared
4091               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4092             {
4093               h->root.u.def.section = s;
4094               h->root.u.def.value = h->plt.offset;
4095             }
4096
4097           /* Make room for this entry.  */
4098           s->_raw_size += PLT_ENTRY_SIZE;
4099
4100           /* We also need to make an entry in the .got.plt section, which
4101              will be placed in the .got section by the linker script.  */
4102           htab->sgotplt->_raw_size += 4;
4103
4104           /* We also need to make an entry in the .rel.plt section.  */
4105           htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
4106         }
4107       else
4108         {
4109           h->plt.offset = (bfd_vma) -1;
4110           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4111         }
4112     }
4113   else
4114     {
4115       h->plt.offset = (bfd_vma) -1;
4116       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4117     }
4118
4119   if (h->got.refcount > 0)
4120     {
4121       asection *s;
4122       boolean dyn;
4123       int tls_type = sh_elf_hash_entry (h)->tls_type;
4124
4125       /* Make sure this symbol is output as a dynamic symbol.
4126          Undefined weak syms won't yet be marked as dynamic.  */
4127       if (h->dynindx == -1
4128           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4129         {
4130           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4131             return false;
4132         }
4133
4134       s = htab->sgot;
4135       h->got.offset = s->_raw_size;
4136       s->_raw_size += 4;
4137       /* R_SH_TLS_GD needs 2 consecutive GOT slots.  */
4138       if (tls_type == GOT_TLS_GD)
4139         s->_raw_size += 4;
4140       dyn = htab->root.dynamic_sections_created;
4141       /* R_SH_TLS_IE_32 needs one dynamic relocation,
4142          R_SH_TLS_GD needs one if local symbol and two if global.  */
4143       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
4144           || tls_type == GOT_TLS_IE)
4145         htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4146       else if (tls_type == GOT_TLS_GD)
4147         htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
4148       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
4149         htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4150     }
4151   else
4152     h->got.offset = (bfd_vma) -1;
4153
4154 #ifdef INCLUDE_SHMEDIA
4155   if (eh->datalabel_got.refcount > 0)
4156     {
4157       asection *s;
4158       boolean dyn;
4159
4160       /* Make sure this symbol is output as a dynamic symbol.
4161          Undefined weak syms won't yet be marked as dynamic.  */
4162       if (h->dynindx == -1
4163           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4164         {
4165           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4166             return false;
4167         }
4168
4169       s = htab->sgot;
4170       eh->datalabel_got.offset = s->_raw_size;
4171       s->_raw_size += 4;
4172       dyn = htab->root.dynamic_sections_created;
4173       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
4174         htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4175     }
4176   else
4177     eh->datalabel_got.offset = (bfd_vma) -1;
4178 #endif
4179
4180   if (eh->dyn_relocs == NULL)
4181     return true;
4182
4183   /* In the shared -Bsymbolic case, discard space allocated for
4184      dynamic pc-relative relocs against symbols which turn out to be
4185      defined in regular objects.  For the normal shared case, discard
4186      space for pc-relative relocs that have become local due to symbol
4187      visibility changes.  */
4188
4189   if (info->shared)
4190     {
4191       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
4192           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
4193               || info->symbolic))
4194         {
4195           struct elf_sh_dyn_relocs **pp;
4196
4197           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
4198             {
4199               p->count -= p->pc_count;
4200               p->pc_count = 0;
4201               if (p->count == 0)
4202                 *pp = p->next;
4203               else
4204                 pp = &p->next;
4205             }
4206         }
4207     }
4208   else
4209     {
4210       if (sh_elf_hash_entry (h)->tls_tpoff32)
4211         goto keep;
4212
4213       /* For the non-shared case, discard space for relocs against
4214          symbols which turn out to need copy relocs or are not
4215          dynamic.  */
4216
4217       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
4218           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4219                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4220               || (htab->root.dynamic_sections_created
4221                   && (h->root.type == bfd_link_hash_undefweak
4222                       || h->root.type == bfd_link_hash_undefined))))
4223         {
4224           /* Make sure this symbol is output as a dynamic symbol.
4225              Undefined weak syms won't yet be marked as dynamic.  */
4226           if (h->dynindx == -1
4227               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4228             {
4229               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4230                 return false;
4231             }
4232
4233           /* If that succeeded, we know we'll be keeping all the
4234              relocs.  */
4235           if (h->dynindx != -1)
4236             goto keep;
4237         }
4238
4239       eh->dyn_relocs = NULL;
4240
4241     keep: ;
4242     }
4243
4244   /* Finally, allocate space.  */
4245   for (p = eh->dyn_relocs; p != NULL; p = p->next)
4246     {
4247       asection *sreloc = elf_section_data (p->sec)->sreloc;
4248       sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
4249     }
4250
4251   return true;
4252 }
4253
4254 /* Find any dynamic relocs that apply to read-only sections.  */
4255
4256 static boolean
4257 readonly_dynrelocs (h, inf)
4258      struct elf_link_hash_entry *h;
4259      PTR inf;
4260 {
4261   struct elf_sh_link_hash_entry *eh;
4262   struct elf_sh_dyn_relocs *p;
4263
4264   if (h->root.type == bfd_link_hash_warning)
4265     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4266
4267   eh = (struct elf_sh_link_hash_entry *) h;
4268   for (p = eh->dyn_relocs; p != NULL; p = p->next)
4269     {
4270       asection *s = p->sec->output_section;
4271
4272       if (s != NULL && (s->flags & SEC_READONLY) != 0)
4273         {
4274           struct bfd_link_info *info = (struct bfd_link_info *) inf;
4275
4276           info->flags |= DF_TEXTREL;
4277
4278           /* Not an error, just cut short the traversal.  */
4279           return false;
4280         }
4281     }
4282   return true;
4283 }
4284
4285 /* Set the sizes of the dynamic sections.  */
4286
4287 static boolean
4288 sh_elf_size_dynamic_sections (output_bfd, info)
4289      bfd *output_bfd ATTRIBUTE_UNUSED;
4290      struct bfd_link_info *info;
4291 {
4292   struct elf_sh_link_hash_table *htab;
4293   bfd *dynobj;
4294   asection *s;
4295   boolean relocs;
4296   bfd *ibfd;
4297
4298   htab = sh_elf_hash_table (info);
4299   dynobj = htab->root.dynobj;
4300   BFD_ASSERT (dynobj != NULL);
4301
4302   if (htab->root.dynamic_sections_created)
4303     {
4304       /* Set the contents of the .interp section to the interpreter.  */
4305       if (! info->shared)
4306         {
4307           s = bfd_get_section_by_name (dynobj, ".interp");
4308           BFD_ASSERT (s != NULL);
4309           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
4310           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4311         }
4312     }
4313
4314   /* Set up .got offsets for local syms, and space for local dynamic
4315      relocs.  */
4316   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4317     {
4318       bfd_signed_vma *local_got;
4319       bfd_signed_vma *end_local_got;
4320       char *local_tls_type;
4321       bfd_size_type locsymcount;
4322       Elf_Internal_Shdr *symtab_hdr;
4323       asection *srel;
4324
4325       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4326         continue;
4327
4328       for (s = ibfd->sections; s != NULL; s = s->next)
4329         {
4330           struct elf_sh_dyn_relocs *p;
4331
4332           for (p = ((struct elf_sh_dyn_relocs *)
4333                     elf_section_data (s)->local_dynrel);
4334                p != NULL;
4335                p = p->next)
4336             {
4337               if (! bfd_is_abs_section (p->sec)
4338                   && bfd_is_abs_section (p->sec->output_section))
4339                 {
4340                   /* Input section has been discarded, either because
4341                      it is a copy of a linkonce section or due to
4342                      linker script /DISCARD/, so we'll be discarding
4343                      the relocs too.  */
4344                 }
4345               else if (p->count != 0)
4346                 {
4347                   srel = elf_section_data (p->sec)->sreloc;
4348                   srel->_raw_size += p->count * sizeof (Elf32_External_Rela);
4349                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4350                     info->flags |= DF_TEXTREL;
4351                 }
4352             }
4353         }
4354
4355       local_got = elf_local_got_refcounts (ibfd);
4356       if (!local_got)
4357         continue;
4358
4359       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4360       locsymcount = symtab_hdr->sh_info;
4361 #ifdef INCLUDE_SHMEDIA
4362       /* Count datalabel local GOT.  */
4363       locsymcount *= 2;
4364 #endif
4365       end_local_got = local_got + locsymcount;
4366       local_tls_type = sh_elf_local_got_tls_type (ibfd);
4367       s = htab->sgot;
4368       srel = htab->srelgot;
4369       for (; local_got < end_local_got; ++local_got)
4370         {
4371           if (*local_got > 0)
4372             {
4373               *local_got = s->_raw_size;
4374               s->_raw_size += 4;
4375               if (*local_tls_type == GOT_TLS_GD)
4376                 s->_raw_size += 4;
4377               if (info->shared)
4378                 srel->_raw_size += sizeof (Elf32_External_Rela);
4379             }
4380           else
4381             *local_got = (bfd_vma) -1;
4382           ++local_tls_type;
4383         }
4384     }
4385
4386   if (htab->tls_ldm_got.refcount > 0)
4387     {
4388       /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
4389          relocs.  */
4390       htab->tls_ldm_got.offset = htab->sgot->_raw_size;
4391       htab->sgot->_raw_size += 8;
4392       htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4393     }
4394   else
4395     htab->tls_ldm_got.offset = -1;
4396
4397   /* Allocate global sym .plt and .got entries, and space for global
4398      sym dynamic relocs.  */
4399   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
4400
4401   /* We now have determined the sizes of the various dynamic sections.
4402      Allocate memory for them.  */
4403   relocs = false;
4404   for (s = dynobj->sections; s != NULL; s = s->next)
4405     {
4406       if ((s->flags & SEC_LINKER_CREATED) == 0)
4407         continue;
4408
4409       if (s == htab->splt
4410           || s == htab->sgot
4411           || s == htab->sgotplt)
4412         {
4413           /* Strip this section if we don't need it; see the
4414              comment below.  */
4415         }
4416       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4417         {
4418           if (s->_raw_size != 0 && s != htab->srelplt)
4419             relocs = true;
4420
4421           /* We use the reloc_count field as a counter if we need
4422              to copy relocs into the output file.  */
4423           s->reloc_count = 0;
4424         }
4425       else
4426         {
4427           /* It's not one of our sections, so don't allocate space.  */
4428           continue;
4429         }
4430
4431       if (s->_raw_size == 0)
4432         {
4433           /* If we don't need this section, strip it from the
4434              output file.  This is mostly to handle .rela.bss and
4435              .rela.plt.  We must create both sections in
4436              create_dynamic_sections, because they must be created
4437              before the linker maps input sections to output
4438              sections.  The linker does that before
4439              adjust_dynamic_symbol is called, and it is that
4440              function which decides whether anything needs to go
4441              into these sections.  */
4442
4443           _bfd_strip_section_from_output (info, s);
4444           continue;
4445         }
4446
4447       /* Allocate memory for the section contents.  We use bfd_zalloc
4448          here in case unused entries are not reclaimed before the
4449          section's contents are written out.  This should not happen,
4450          but this way if it does, we get a R_SH_NONE reloc instead
4451          of garbage.  */
4452       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
4453       if (s->contents == NULL)
4454         return false;
4455     }
4456
4457   if (htab->root.dynamic_sections_created)
4458     {
4459       /* Add some entries to the .dynamic section.  We fill in the
4460          values later, in sh_elf_finish_dynamic_sections, but we
4461          must add the entries now so that we get the correct size for
4462          the .dynamic section.  The DT_DEBUG entry is filled in by the
4463          dynamic linker and used by the debugger.  */
4464 #define add_dynamic_entry(TAG, VAL) \
4465   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
4466
4467       if (! info->shared)
4468         {
4469           if (! add_dynamic_entry (DT_DEBUG, 0))
4470             return false;
4471         }
4472
4473       if (htab->splt->_raw_size != 0)
4474         {
4475           if (! add_dynamic_entry (DT_PLTGOT, 0)
4476               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
4477               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
4478               || ! add_dynamic_entry (DT_JMPREL, 0))
4479             return false;
4480         }
4481
4482       if (relocs)
4483         {
4484           if (! add_dynamic_entry (DT_RELA, 0)
4485               || ! add_dynamic_entry (DT_RELASZ, 0)
4486               || ! add_dynamic_entry (DT_RELAENT,
4487                                       sizeof (Elf32_External_Rela)))
4488             return false;
4489
4490           /* If any dynamic relocs apply to a read-only section,
4491              then we need a DT_TEXTREL entry.  */
4492           if ((info->flags & DF_TEXTREL) == 0)
4493             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
4494                                     (PTR) info);
4495
4496           if ((info->flags & DF_TEXTREL) != 0)
4497             {
4498               if (! add_dynamic_entry (DT_TEXTREL, 0))
4499                 return false;
4500             }
4501         }
4502     }
4503 #undef add_dynamic_entry
4504
4505   return true;
4506 }
4507 \f
4508 /* Relocate an SH ELF section.  */
4509
4510 static boolean
4511 sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
4512                          contents, relocs, local_syms, local_sections)
4513      bfd *output_bfd;
4514      struct bfd_link_info *info;
4515      bfd *input_bfd;
4516      asection *input_section;
4517      bfd_byte *contents;
4518      Elf_Internal_Rela *relocs;
4519      Elf_Internal_Sym *local_syms;
4520      asection **local_sections;
4521 {
4522   struct elf_sh_link_hash_table *htab;
4523   Elf_Internal_Shdr *symtab_hdr;
4524   struct elf_link_hash_entry **sym_hashes;
4525   Elf_Internal_Rela *rel, *relend;
4526   bfd *dynobj;
4527   bfd_vma *local_got_offsets;
4528   asection *sgot;
4529   asection *sgotplt;
4530   asection *splt;
4531   asection *sreloc;
4532   asection *srelgot;
4533
4534   htab = sh_elf_hash_table (info);
4535   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4536   sym_hashes = elf_sym_hashes (input_bfd);
4537   dynobj = htab->root.dynobj;
4538   local_got_offsets = elf_local_got_offsets (input_bfd);
4539
4540   sgot = htab->sgot;
4541   sgotplt = htab->sgotplt;
4542   splt = htab->splt;
4543   sreloc = NULL;
4544   srelgot = NULL;
4545
4546   rel = relocs;
4547   relend = relocs + input_section->reloc_count;
4548   for (; rel < relend; rel++)
4549     {
4550       int r_type;
4551       reloc_howto_type *howto;
4552       unsigned long r_symndx;
4553       Elf_Internal_Sym *sym;
4554       asection *sec;
4555       struct elf_link_hash_entry *h;
4556       bfd_vma relocation;
4557       bfd_vma addend = (bfd_vma) 0;
4558       bfd_reloc_status_type r;
4559       int seen_stt_datalabel = 0;
4560       bfd_vma off;
4561       int tls_type;
4562
4563       r_symndx = ELF32_R_SYM (rel->r_info);
4564
4565       r_type = ELF32_R_TYPE (rel->r_info);
4566
4567       /* Many of the relocs are only used for relaxing, and are
4568          handled entirely by the relaxation code.  */
4569       if (r_type > (int) R_SH_LAST_INVALID_RELOC
4570           && r_type < (int) R_SH_LOOP_START)
4571         continue;
4572       if (r_type == (int) R_SH_NONE)
4573         continue;
4574
4575       if (r_type < 0
4576           || r_type >= R_SH_max
4577           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
4578               && r_type <= (int) R_SH_LAST_INVALID_RELOC)
4579           || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_3
4580               && r_type <= (int) R_SH_LAST_INVALID_RELOC_3)
4581           || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
4582               && r_type <= (int) R_SH_LAST_INVALID_RELOC_4)
4583           || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_5
4584               && r_type <= (int) R_SH_LAST_INVALID_RELOC_5)
4585           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
4586               && r_type <= (int) R_SH_LAST_INVALID_RELOC_2))
4587         {
4588           bfd_set_error (bfd_error_bad_value);
4589           return false;
4590         }
4591
4592       howto = sh_elf_howto_table + r_type;
4593
4594       /* For relocs that aren't partial_inplace, we get the addend from
4595          the relocation.  */
4596       if (! howto->partial_inplace)
4597         addend = rel->r_addend;
4598
4599       h = NULL;
4600       sym = NULL;
4601       sec = NULL;
4602       if (r_symndx < symtab_hdr->sh_info)
4603         {
4604           sym = local_syms + r_symndx;
4605           sec = local_sections[r_symndx];
4606           relocation = (sec->output_section->vma
4607                         + sec->output_offset
4608                         + sym->st_value);
4609           /* A local symbol never has STO_SH5_ISA32, so we don't need
4610              datalabel processing here.  Make sure this does not change
4611              without notice.  */
4612           if ((sym->st_other & STO_SH5_ISA32) != 0)
4613             ((*info->callbacks->reloc_dangerous)
4614              (info,
4615               _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
4616               input_bfd, input_section, rel->r_offset));
4617           if (info->relocateable)
4618             {
4619               /* This is a relocateable link.  We don't have to change
4620                  anything, unless the reloc is against a section symbol,
4621                  in which case we have to adjust according to where the
4622                  section symbol winds up in the output section.  */
4623               sym = local_syms + r_symndx;
4624               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4625                 {
4626                   if (! howto->partial_inplace)
4627                     {
4628                       /* For relocations with the addend in the
4629                          relocation, we need just to update the addend.
4630                          All real relocs are of type partial_inplace; this
4631                          code is mostly for completeness.  */
4632                       rel->r_addend += sec->output_offset + sym->st_value;
4633
4634                       continue;
4635                     }
4636
4637                   /* Relocs of type partial_inplace need to pick up the
4638                      contents in the contents and add the offset resulting
4639                      from the changed location of the section symbol.
4640                      Using _bfd_final_link_relocate (e.g. goto
4641                      final_link_relocate) here would be wrong, because
4642                      relocations marked pc_relative would get the current
4643                      location subtracted, and we must only do that at the
4644                      final link.  */
4645                   r = _bfd_relocate_contents (howto, input_bfd,
4646                                               sec->output_offset
4647                                               + sym->st_value,
4648                                               contents + rel->r_offset);
4649                   goto relocation_done;
4650                 }
4651
4652               continue;
4653             }
4654           else if (! howto->partial_inplace)
4655             {
4656               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
4657               addend = rel->r_addend;
4658             }
4659           else if ((sec->flags & SEC_MERGE)
4660                    && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4661             {
4662               asection *msec;
4663
4664               if (howto->rightshift || howto->src_mask != 0xffffffff)
4665                 {
4666                   (*_bfd_error_handler)
4667                     (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
4668                      bfd_archive_filename (input_bfd),
4669                      bfd_get_section_name (input_bfd, input_section),
4670                      (long) rel->r_offset, howto->name);
4671                   return false;
4672                 }
4673
4674               addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4675               msec = sec;
4676               addend =
4677                 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4678                 - relocation;
4679               addend += msec->output_section->vma + msec->output_offset;
4680               bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
4681               addend = 0;
4682             }
4683         }
4684       else
4685         {
4686           /* Section symbol are never (?) placed in the hash table, so
4687              we can just ignore hash relocations when creating a
4688              relocateable object file.  */
4689           if (info->relocateable)
4690             continue;
4691
4692           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4693           while (h->root.type == bfd_link_hash_indirect
4694                  || h->root.type == bfd_link_hash_warning)
4695             {
4696 #ifdef INCLUDE_SHMEDIA
4697               /* If the reference passes a symbol marked with
4698                  STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4699                  doesn't count.  */
4700               seen_stt_datalabel |= h->type == STT_DATALABEL;
4701 #endif
4702               h = (struct elf_link_hash_entry *) h->root.u.i.link;
4703             }
4704           if (h->root.type == bfd_link_hash_defined
4705               || h->root.type == bfd_link_hash_defweak)
4706             {
4707               boolean dyn;
4708
4709               dyn = htab->root.dynamic_sections_created;
4710               sec = h->root.u.def.section;
4711               /* In these cases, we don't need the relocation value.
4712                  We check specially because in some obscure cases
4713                  sec->output_section will be NULL.  */
4714               if (r_type == R_SH_GOTPC
4715                   || r_type == R_SH_GOTPC_LOW16
4716                   || r_type == R_SH_GOTPC_MEDLOW16
4717                   || r_type == R_SH_GOTPC_MEDHI16
4718                   || r_type == R_SH_GOTPC_HI16
4719                   || ((r_type == R_SH_PLT32
4720                        || r_type == R_SH_PLT_LOW16
4721                        || r_type == R_SH_PLT_MEDLOW16
4722                        || r_type == R_SH_PLT_MEDHI16
4723                        || r_type == R_SH_PLT_HI16)
4724                       && h->plt.offset != (bfd_vma) -1)
4725                   || ((r_type == R_SH_GOT32
4726                        || r_type == R_SH_GOT_LOW16
4727                        || r_type == R_SH_GOT_MEDLOW16
4728                        || r_type == R_SH_GOT_MEDHI16
4729                        || r_type == R_SH_GOT_HI16)
4730                       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
4731                       && (! info->shared
4732                           || (! info->symbolic && h->dynindx != -1)
4733                           || (h->elf_link_hash_flags
4734                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
4735                   /* The cases above are those in which relocation is
4736                      overwritten in the switch block below.  The cases
4737                      below are those in which we must defer relocation
4738                      to run-time, because we can't resolve absolute
4739                      addresses when creating a shared library.  */
4740                   || (info->shared
4741                       && ((! info->symbolic && h->dynindx != -1)
4742                           || (h->elf_link_hash_flags
4743                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
4744                       && ((r_type == R_SH_DIR32
4745                            && (h->elf_link_hash_flags
4746                                & ELF_LINK_FORCED_LOCAL) == 0)
4747                           || r_type == R_SH_REL32)
4748                       && ((input_section->flags & SEC_ALLOC) != 0
4749                           /* DWARF will emit R_SH_DIR32 relocations in its
4750                              sections against symbols defined externally
4751                              in shared libraries.  We can't do anything
4752                              with them here.  */
4753                           || ((input_section->flags & SEC_DEBUGGING) != 0
4754                               && (h->elf_link_hash_flags
4755                                   & ELF_LINK_HASH_DEF_DYNAMIC) != 0)))
4756                   /* Dynamic relocs are not propagated for SEC_DEBUGGING
4757                      sections because such sections are not SEC_ALLOC and
4758                      thus ld.so will not process them.  */
4759                   || (sec->output_section == NULL
4760                       && ((input_section->flags & SEC_DEBUGGING) != 0
4761                           && (h->elf_link_hash_flags
4762                               & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
4763                   || (sec->output_section == NULL
4764                       && (sh_elf_hash_entry (h)->tls_type == GOT_TLS_IE
4765                           || sh_elf_hash_entry (h)->tls_type == GOT_TLS_GD)))
4766                 relocation = 0;
4767               else if (sec->output_section == NULL)
4768                 {
4769                   (*_bfd_error_handler)
4770                     (_("%s: unresolvable relocation against symbol `%s' from %s section"),
4771                      bfd_archive_filename (input_bfd), h->root.root.string,
4772                      bfd_get_section_name (input_bfd, input_section));
4773                   return false;
4774                 }
4775               else
4776                 relocation = ((h->root.u.def.value
4777                               + sec->output_section->vma
4778                               + sec->output_offset)
4779                               /* A STO_SH5_ISA32 causes a "bitor 1" to the
4780                                  symbol value, unless we've seen
4781                                  STT_DATALABEL on the way to it.  */
4782                               | ((h->other & STO_SH5_ISA32) != 0
4783                                  && ! seen_stt_datalabel));
4784             }
4785           else if (h->root.type == bfd_link_hash_undefweak)
4786             relocation = 0;
4787           else if (info->shared
4788                    && (! info->symbolic || info->allow_shlib_undefined)
4789                    && ! info->no_undefined
4790                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4791             relocation = 0;
4792           else
4793             {
4794               if (! ((*info->callbacks->undefined_symbol)
4795                      (info, h->root.root.string, input_bfd,
4796                       input_section, rel->r_offset,
4797                       (!info->shared || info->no_undefined
4798                        || ELF_ST_VISIBILITY (h->other)))))
4799                 return false;
4800               relocation = 0;
4801             }
4802         }
4803
4804       switch ((int) r_type)
4805         {
4806         final_link_relocate:
4807           /* COFF relocs don't use the addend. The addend is used for
4808              R_SH_DIR32 to be compatible with other compilers.  */
4809           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4810                                         contents, rel->r_offset,
4811                                         relocation, addend);
4812           break;
4813
4814         case R_SH_IND12W:
4815           relocation -= 4;
4816           goto final_link_relocate;
4817
4818         case R_SH_DIR8WPN:
4819         case R_SH_DIR8WPZ:
4820         case R_SH_DIR8WPL:
4821           /* If the reloc is against the start of this section, then
4822              the assembler has already taken care of it and the reloc
4823              is here only to assist in relaxing.  If the reloc is not
4824              against the start of this section, then it's against an
4825              external symbol and we must deal with it ourselves.  */
4826           if (input_section->output_section->vma + input_section->output_offset
4827               != relocation)
4828             {
4829               int disp = (relocation
4830                           - input_section->output_section->vma
4831                           - input_section->output_offset
4832                           - rel->r_offset);
4833               int mask = 0;
4834               switch (r_type)
4835                 {
4836                 case R_SH_DIR8WPN:
4837                 case R_SH_DIR8WPZ: mask = 1; break;
4838                 case R_SH_DIR8WPL: mask = 3; break;
4839                 default: mask = 0; break;
4840                 }
4841               if (disp & mask)
4842                 {
4843                   ((*_bfd_error_handler)
4844                    (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
4845                     bfd_archive_filename (input_section->owner),
4846                     (unsigned long) rel->r_offset));
4847                   bfd_set_error (bfd_error_bad_value);
4848                   return false;
4849                 }
4850               relocation -= 4;
4851               goto final_link_relocate;
4852             }
4853           r = bfd_reloc_ok;
4854           break;
4855
4856         default:
4857 #ifdef INCLUDE_SHMEDIA
4858           if (shmedia_prepare_reloc (info, input_bfd, input_section,
4859                                      contents, rel, &relocation))
4860             goto final_link_relocate;
4861 #endif
4862           bfd_set_error (bfd_error_bad_value);
4863           return false;
4864
4865         case R_SH_DIR32:
4866         case R_SH_REL32:
4867           if (info->shared
4868               && r_symndx != 0
4869               && (input_section->flags & SEC_ALLOC) != 0
4870               && (r_type != R_SH_REL32
4871                   || (h != NULL
4872                       && h->dynindx != -1
4873                       && (! info->symbolic
4874                           || (h->elf_link_hash_flags
4875                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
4876             {
4877               Elf_Internal_Rela outrel;
4878               boolean skip, relocate;
4879
4880               /* When generating a shared object, these relocations
4881                  are copied into the output file to be resolved at run
4882                  time.  */
4883
4884               if (sreloc == NULL)
4885                 {
4886                   const char *name;
4887
4888                   name = (bfd_elf_string_from_elf_section
4889                           (input_bfd,
4890                            elf_elfheader (input_bfd)->e_shstrndx,
4891                            elf_section_data (input_section)->rel_hdr.sh_name));
4892                   if (name == NULL)
4893                     return false;
4894
4895                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4896                               && strcmp (bfd_get_section_name (input_bfd,
4897                                                                input_section),
4898                                          name + 5) == 0);
4899
4900                   sreloc = bfd_get_section_by_name (dynobj, name);
4901                   BFD_ASSERT (sreloc != NULL);
4902                 }
4903
4904               skip = false;
4905               relocate = false;
4906
4907               outrel.r_offset =
4908                 _bfd_elf_section_offset (output_bfd, info, input_section,
4909                                          rel->r_offset);
4910               if (outrel.r_offset == (bfd_vma) -1)
4911                 skip = true;
4912               else if (outrel.r_offset == (bfd_vma) -2)
4913                 skip = true, relocate = true;
4914               outrel.r_offset += (input_section->output_section->vma
4915                                   + input_section->output_offset);
4916
4917               if (skip)
4918                 memset (&outrel, 0, sizeof outrel);
4919               else if (r_type == R_SH_REL32)
4920                 {
4921                   BFD_ASSERT (h != NULL && h->dynindx != -1);
4922                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
4923                   outrel.r_addend
4924                     = bfd_get_32 (input_bfd, contents + rel->r_offset);
4925                 }
4926               else
4927                 {
4928                   /* h->dynindx may be -1 if this symbol was marked to
4929                      become local.  */
4930                   if (h == NULL
4931                       || ((info->symbolic || h->dynindx == -1)
4932                           && (h->elf_link_hash_flags
4933                               & ELF_LINK_HASH_DEF_REGULAR) != 0))
4934                     {
4935                       relocate = true;
4936                       outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4937                       outrel.r_addend
4938                         = relocation + bfd_get_32 (input_bfd,
4939                                                    contents + rel->r_offset);
4940                     }
4941                   else
4942                     {
4943                       BFD_ASSERT (h->dynindx != -1);
4944                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
4945                       outrel.r_addend
4946                         = relocation + bfd_get_32 (input_bfd,
4947                                                    contents + rel->r_offset);
4948                     }
4949                 }
4950
4951               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4952                                          (((Elf32_External_Rela *)
4953                                            sreloc->contents)
4954                                           + sreloc->reloc_count));
4955               ++sreloc->reloc_count;
4956
4957               /* If this reloc is against an external symbol, we do
4958                  not want to fiddle with the addend.  Otherwise, we
4959                  need to include the symbol value so that it becomes
4960                  an addend for the dynamic reloc.  */
4961               if (! relocate)
4962                 continue;
4963             }
4964           goto final_link_relocate;
4965
4966         case R_SH_GOTPLT32:
4967 #ifdef INCLUDE_SHMEDIA
4968         case R_SH_GOTPLT_LOW16:
4969         case R_SH_GOTPLT_MEDLOW16:
4970         case R_SH_GOTPLT_MEDHI16:
4971         case R_SH_GOTPLT_HI16:
4972         case R_SH_GOTPLT10BY4:
4973         case R_SH_GOTPLT10BY8:
4974 #endif
4975           /* Relocation is to the entry for this symbol in the
4976              procedure linkage table.  */
4977
4978           if (h == NULL
4979               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
4980               || ! info->shared
4981               || info->symbolic
4982               || h->dynindx == -1
4983               || h->plt.offset == (bfd_vma) -1
4984               || h->got.offset != (bfd_vma) -1)
4985             goto force_got;
4986
4987           /* Relocation is to the entry for this symbol in the global
4988              offset table extension for the procedure linkage table.  */
4989
4990           BFD_ASSERT (sgotplt != NULL);
4991           relocation = (sgotplt->output_offset
4992                         + ((h->plt.offset / elf_sh_sizeof_plt (info)
4993                             - 1 + 3) * 4));
4994
4995 #ifdef GOT_BIAS
4996           relocation -= GOT_BIAS;
4997 #endif
4998
4999           goto final_link_relocate;
5000
5001         force_got:
5002         case R_SH_GOT32:
5003 #ifdef INCLUDE_SHMEDIA
5004         case R_SH_GOT_LOW16:
5005         case R_SH_GOT_MEDLOW16:
5006         case R_SH_GOT_MEDHI16:
5007         case R_SH_GOT_HI16:
5008         case R_SH_GOT10BY4:
5009         case R_SH_GOT10BY8:
5010 #endif
5011           /* Relocation is to the entry for this symbol in the global
5012              offset table.  */
5013
5014           BFD_ASSERT (sgot != NULL);
5015
5016           if (h != NULL)
5017             {
5018               boolean dyn;
5019
5020               off = h->got.offset;
5021 #ifdef INCLUDE_SHMEDIA
5022               if (seen_stt_datalabel)
5023                 {
5024                   struct elf_sh_link_hash_entry *hsh;
5025
5026                   hsh = (struct elf_sh_link_hash_entry *)h;
5027                   off = hsh->datalabel_got.offset;
5028                 }
5029 #endif
5030               BFD_ASSERT (off != (bfd_vma) -1);
5031
5032               dyn = htab->root.dynamic_sections_created;
5033               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
5034                   || (info->shared
5035                       && (info->symbolic || h->dynindx == -1
5036                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
5037                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5038                 {
5039                   /* This is actually a static link, or it is a
5040                      -Bsymbolic link and the symbol is defined
5041                      locally, or the symbol was forced to be local
5042                      because of a version file.  We must initialize
5043                      this entry in the global offset table.  Since the
5044                      offset must always be a multiple of 4, we use the
5045                      least significant bit to record whether we have
5046                      initialized it already.
5047
5048                      When doing a dynamic link, we create a .rela.got
5049                      relocation entry to initialize the value.  This
5050                      is done in the finish_dynamic_symbol routine.  */
5051                   if ((off & 1) != 0)
5052                     off &= ~1;
5053                   else
5054                     {
5055                       bfd_put_32 (output_bfd, relocation,
5056                                   sgot->contents + off);
5057 #ifdef INCLUDE_SHMEDIA
5058                       if (seen_stt_datalabel)
5059                         {
5060                           struct elf_sh_link_hash_entry *hsh;
5061
5062                           hsh = (struct elf_sh_link_hash_entry *)h;
5063                           hsh->datalabel_got.offset |= 1;
5064                         }
5065                       else
5066 #endif
5067                         h->got.offset |= 1;
5068                     }
5069                 }
5070
5071               relocation = sgot->output_offset + off;
5072             }
5073           else
5074             {
5075 #ifdef INCLUDE_SHMEDIA
5076               if (rel->r_addend)
5077                 {
5078                   BFD_ASSERT (local_got_offsets != NULL
5079                               && (local_got_offsets[symtab_hdr->sh_info
5080                                                     + r_symndx]
5081                                   != (bfd_vma) -1));
5082
5083                   off = local_got_offsets[symtab_hdr->sh_info
5084                                           + r_symndx];
5085                 }
5086               else
5087                 {
5088 #endif
5089               BFD_ASSERT (local_got_offsets != NULL
5090                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
5091
5092               off = local_got_offsets[r_symndx];
5093 #ifdef INCLUDE_SHMEDIA
5094                 }
5095 #endif
5096
5097               /* The offset must always be a multiple of 4.  We use
5098                  the least significant bit to record whether we have
5099                  already generated the necessary reloc.  */
5100               if ((off & 1) != 0)
5101                 off &= ~1;
5102               else
5103                 {
5104                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5105
5106                   if (info->shared)
5107                     {
5108                       Elf_Internal_Rela outrel;
5109
5110                       if (srelgot == NULL)
5111                         {
5112                           srelgot = bfd_get_section_by_name (dynobj,
5113                                                              ".rela.got");
5114                           BFD_ASSERT (srelgot != NULL);
5115                         }
5116
5117                       outrel.r_offset = (sgot->output_section->vma
5118                                          + sgot->output_offset
5119                                          + off);
5120                       outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
5121                       outrel.r_addend = relocation;
5122                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,
5123                                                 (((Elf32_External_Rela *)
5124                                                   srelgot->contents)
5125                                                  + srelgot->reloc_count));
5126                       ++srelgot->reloc_count;
5127                     }
5128
5129 #ifdef INCLUDE_SHMEDIA
5130                   if (rel->r_addend)
5131                     local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
5132                   else
5133 #endif
5134                     local_got_offsets[r_symndx] |= 1;
5135                 }
5136
5137               relocation = sgot->output_offset + off;
5138             }
5139
5140 #ifdef GOT_BIAS
5141           relocation -= GOT_BIAS;
5142 #endif
5143
5144           goto final_link_relocate;
5145
5146         case R_SH_GOTOFF:
5147 #ifdef INCLUDE_SHMEDIA
5148         case R_SH_GOTOFF_LOW16:
5149         case R_SH_GOTOFF_MEDLOW16:
5150         case R_SH_GOTOFF_MEDHI16:
5151         case R_SH_GOTOFF_HI16:
5152 #endif
5153           /* Relocation is relative to the start of the global offset
5154              table.  */
5155
5156           BFD_ASSERT (sgot != NULL);
5157
5158           /* Note that sgot->output_offset is not involved in this
5159              calculation.  We always want the start of .got.  If we
5160              defined _GLOBAL_OFFSET_TABLE in a different way, as is
5161              permitted by the ABI, we might have to change this
5162              calculation.  */
5163           relocation -= sgot->output_section->vma;
5164
5165 #ifdef GOT_BIAS
5166           relocation -= GOT_BIAS;
5167 #endif
5168
5169           addend = rel->r_addend;
5170
5171           goto final_link_relocate;
5172
5173         case R_SH_GOTPC:
5174 #ifdef INCLUDE_SHMEDIA
5175         case R_SH_GOTPC_LOW16:
5176         case R_SH_GOTPC_MEDLOW16:
5177         case R_SH_GOTPC_MEDHI16:
5178         case R_SH_GOTPC_HI16:
5179 #endif
5180           /* Use global offset table as symbol value.  */
5181
5182           BFD_ASSERT (sgot != NULL);
5183           relocation = sgot->output_section->vma;
5184
5185 #ifdef GOT_BIAS
5186           relocation += GOT_BIAS;
5187 #endif
5188
5189           addend = rel->r_addend;
5190
5191           goto final_link_relocate;
5192
5193         case R_SH_PLT32:
5194 #ifdef INCLUDE_SHMEDIA
5195         case R_SH_PLT_LOW16:
5196         case R_SH_PLT_MEDLOW16:
5197         case R_SH_PLT_MEDHI16:
5198         case R_SH_PLT_HI16:
5199 #endif
5200           /* Relocation is to the entry for this symbol in the
5201              procedure linkage table.  */
5202
5203           /* Resolve a PLT reloc against a local symbol directly,
5204              without using the procedure linkage table.  */
5205           if (h == NULL)
5206             goto final_link_relocate;
5207
5208           if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
5209             goto final_link_relocate;
5210
5211           if (h->plt.offset == (bfd_vma) -1)
5212             {
5213               /* We didn't make a PLT entry for this symbol.  This
5214                  happens when statically linking PIC code, or when
5215                  using -Bsymbolic.  */
5216               goto final_link_relocate;
5217             }
5218
5219           BFD_ASSERT (splt != NULL);
5220           relocation = (splt->output_section->vma
5221                         + splt->output_offset
5222                         + h->plt.offset);
5223
5224 #ifdef INCLUDE_SHMEDIA
5225           relocation++;
5226 #endif
5227
5228           addend = rel->r_addend;
5229
5230           goto final_link_relocate;
5231
5232         case R_SH_LOOP_START:
5233           {
5234             static bfd_vma start, end;
5235
5236             start = (relocation + rel->r_addend
5237                      - (sec->output_section->vma + sec->output_offset));
5238             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5239                                    rel->r_offset, sec, start, end);
5240             break;
5241
5242         case R_SH_LOOP_END:
5243             end = (relocation + rel->r_addend
5244                    - (sec->output_section->vma + sec->output_offset));
5245             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5246                                    rel->r_offset, sec, start, end);
5247             break;
5248           }
5249
5250         case R_SH_TLS_GD_32:
5251         case R_SH_TLS_IE_32:
5252           r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5253           tls_type = GOT_UNKNOWN;
5254           if (h == NULL && local_got_offsets)
5255             tls_type = sh_elf_local_got_tls_type (input_bfd) [r_symndx];
5256           else if (h != NULL)
5257             {
5258               tls_type = sh_elf_hash_entry (h)->tls_type;
5259               if (! info->shared
5260                   && (h->dynindx == -1
5261                       || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
5262                   && (tls_type == GOT_TLS_IE
5263                       || sh_elf_hash_entry (h)->tls_tpoff32))
5264                 r_type = R_SH_TLS_LE_32;
5265             }
5266
5267           if (r_type == R_SH_TLS_GD_32 && tls_type == GOT_TLS_IE)
5268             r_type = R_SH_TLS_IE_32;
5269
5270           if (r_type == R_SH_TLS_LE_32)
5271             {
5272               bfd_vma offset;
5273               unsigned short insn;
5274               int indx;
5275               Elf_Internal_Rela outrel;
5276
5277               if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
5278                 {
5279                   /* GD->LE transition:
5280                        mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5281                        jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5282                        1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5283                      We change it into:
5284                        mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5285                        nop; nop; ...
5286                        1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:.  */
5287
5288                   offset = rel->r_offset;
5289                   BFD_ASSERT (offset >= 16);
5290                   /* Size of GD instructions is 16 or 18.  */
5291                   offset -= 16;
5292                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5293                   if ((insn & 0xff00) == 0xc700)
5294                     {
5295                       BFD_ASSERT (offset >= 2);
5296                       offset -= 2;
5297                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
5298                     }
5299
5300                   BFD_ASSERT ((insn & 0xff00) == 0xd400);
5301                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
5302                   BFD_ASSERT ((insn & 0xff00) == 0xc700);
5303                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
5304                   BFD_ASSERT ((insn & 0xff00) == 0xd100);
5305                   insn = bfd_get_16 (input_bfd, contents + offset + 6);
5306                   BFD_ASSERT (insn == 0x310c);
5307                   insn = bfd_get_16 (input_bfd, contents + offset + 8);
5308                   BFD_ASSERT (insn == 0x410b);
5309                   insn = bfd_get_16 (input_bfd, contents + offset + 10);
5310                   BFD_ASSERT (insn == 0x34cc);
5311
5312                   bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
5313                   bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
5314                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5315                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5316                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5317                 }
5318               else
5319                 {
5320                   int index;
5321
5322                   /* IE->LE transition:
5323                      mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5324                      bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5325                      We change it into:
5326                      mov.l .Ln,rM; stc gbr,rN; nop; ...;
5327                      1: x@TPOFF; 2:.  */
5328
5329                   offset = rel->r_offset;
5330                   BFD_ASSERT (offset >= 16);
5331                   /* Size of IE instructions is 10 or 12.  */
5332                   offset -= 10;
5333                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5334                   if ((insn & 0xf0ff) == 0x0012)
5335                     {
5336                       BFD_ASSERT (offset >= 2);
5337                       offset -= 2;
5338                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
5339                     }
5340
5341                   BFD_ASSERT ((insn & 0xff00) == 0xd000);
5342                   index = insn & 0x00ff;
5343                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
5344                   BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
5345                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
5346                   BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
5347                   insn = 0xd000 | (insn & 0x0f00) | index;
5348                   bfd_put_16 (output_bfd, insn, contents + offset + 0);
5349                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5350                 }
5351
5352               if (sreloc == NULL)
5353                 {
5354                   const char *name;
5355
5356                   name = (bfd_elf_string_from_elf_section
5357                           (input_bfd,
5358                            elf_elfheader (input_bfd)->e_shstrndx,
5359                            elf_section_data (input_section)->rel_hdr.sh_name));
5360                   if (name == NULL)
5361                     return false;
5362
5363                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5364                               && strcmp (bfd_get_section_name (input_bfd,
5365                                                                input_section),
5366                                          name + 5) == 0);
5367
5368                   sreloc = bfd_get_section_by_name (dynobj, name);
5369                   BFD_ASSERT (sreloc != NULL);
5370                 }
5371
5372               indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5373               outrel.r_offset = (input_section->output_section->vma
5374                                  + input_section->output_offset
5375                                  + rel->r_offset);
5376               outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5377               if (indx == 0)
5378                 outrel.r_addend = relocation - dtpoff_base (info);
5379               else
5380                 outrel.r_addend = 0;
5381               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
5382                                          (((Elf32_External_Rela *)
5383                                            sreloc->contents)
5384                                           + sreloc->reloc_count));
5385               ++sreloc->reloc_count;
5386
5387               continue;
5388             }
5389
5390           sgot = htab->sgot;
5391           if (sgot == NULL)
5392             abort ();
5393
5394           if (h != NULL)
5395             off = h->got.offset;
5396           else
5397             {
5398               if (local_got_offsets == NULL)
5399                 abort ();
5400
5401               off = local_got_offsets[r_symndx];
5402             }
5403
5404           if ((off & 1) != 0)
5405             off &= ~1;
5406           else
5407             {
5408               Elf_Internal_Rela outrel;
5409               Elf32_External_Rela *loc;
5410               int dr_type, indx;
5411
5412               if (srelgot == NULL)
5413                 {
5414                   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5415                   BFD_ASSERT (srelgot != NULL);
5416                 }
5417
5418               outrel.r_offset = (sgot->output_section->vma
5419                                  + sgot->output_offset + off);
5420
5421               indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5422               dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
5423                          R_SH_TLS_TPOFF32);
5424               if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
5425                 outrel.r_addend = relocation - dtpoff_base (info);
5426               else
5427                 outrel.r_addend = 0;
5428               outrel.r_info = ELF32_R_INFO (indx, dr_type);
5429               loc = (Elf32_External_Rela *) srelgot->contents;
5430               loc += srelgot->reloc_count++;
5431               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5432
5433               if (r_type == R_SH_TLS_GD_32)
5434                 {
5435                   if (indx == 0)
5436                     {
5437                       bfd_put_32 (output_bfd,
5438                                   relocation - dtpoff_base (info),
5439                                   sgot->contents + off + 4);
5440                     }
5441                   else
5442                     {
5443                       outrel.r_info = ELF32_R_INFO (indx,
5444                                                     R_SH_TLS_DTPOFF32);
5445                       outrel.r_offset += 4;
5446                       outrel.r_addend = 0;
5447                       srelgot->reloc_count++;
5448                       loc++;
5449                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,
5450                                                 loc);
5451                     }
5452                 }
5453
5454               if (h != NULL)
5455                 h->got.offset |= 1;
5456               else
5457                 local_got_offsets[r_symndx] |= 1;
5458             }
5459
5460           if (off >= (bfd_vma) -2)
5461             abort ();
5462
5463           if (r_type == (int) ELF32_R_TYPE (rel->r_info))
5464             relocation = sgot->output_offset + off;
5465           else
5466             {
5467               bfd_vma offset;
5468               unsigned short insn;
5469
5470               /* GD->IE transition:
5471                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5472                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5473                    1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5474                  We change it into:
5475                    mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5476                    nop; nop; bra 3f; nop; .align 2;
5477                    1: .long x@TPOFF; 2:...; 3:.  */
5478
5479               offset = rel->r_offset;
5480               BFD_ASSERT (offset >= 16);
5481               /* Size of GD instructions is 16 or 18.  */
5482               offset -= 16;
5483               insn = bfd_get_16 (input_bfd, contents + offset + 0);
5484               if ((insn & 0xff00) == 0xc700)
5485                 {
5486                   BFD_ASSERT (offset >= 2);
5487                   offset -= 2;
5488                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5489                 }
5490
5491               BFD_ASSERT ((insn & 0xff00) == 0xd400);
5492
5493               /* Replace mov.l 1f,R4 with mov.l 1f,r0.  */
5494               bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
5495
5496               insn = bfd_get_16 (input_bfd, contents + offset + 2);
5497               BFD_ASSERT ((insn & 0xff00) == 0xc700);
5498               insn = bfd_get_16 (input_bfd, contents + offset + 4);
5499               BFD_ASSERT ((insn & 0xff00) == 0xd100);
5500               insn = bfd_get_16 (input_bfd, contents + offset + 6);
5501               BFD_ASSERT (insn == 0x310c);
5502               insn = bfd_get_16 (input_bfd, contents + offset + 8);
5503               BFD_ASSERT (insn == 0x410b);
5504               insn = bfd_get_16 (input_bfd, contents + offset + 10);
5505               BFD_ASSERT (insn == 0x34cc);
5506
5507               bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
5508               bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
5509               bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
5510               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5511               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5512
5513               bfd_put_32 (output_bfd, sgot->output_offset + off,
5514                           contents + rel->r_offset);
5515
5516               continue;
5517           }
5518
5519           addend = rel->r_addend;
5520
5521           goto final_link_relocate;
5522
5523         case R_SH_TLS_LD_32:
5524           if (! info->shared)
5525             {
5526               bfd_vma offset;
5527               unsigned short insn;
5528
5529               /* LD->LE transition:
5530                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5531                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5532                    1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5533                  We change it into:
5534                    stc gbr,r0; nop; nop; nop;
5535                    nop; nop; bra 3f; ...; 3:.  */
5536
5537               offset = rel->r_offset;
5538               BFD_ASSERT (offset >= 16);
5539               /* Size of LD instructions is 16 or 18.  */
5540               offset -= 16;
5541               insn = bfd_get_16 (input_bfd, contents + offset + 0);
5542               if ((insn & 0xff00) == 0xc700)
5543                 {
5544                   BFD_ASSERT (offset >= 2);
5545                   offset -= 2;
5546                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5547                 }
5548
5549               BFD_ASSERT ((insn & 0xff00) == 0xd400);
5550               insn = bfd_get_16 (input_bfd, contents + offset + 2);
5551               BFD_ASSERT ((insn & 0xff00) == 0xc700);
5552               insn = bfd_get_16 (input_bfd, contents + offset + 4);
5553               BFD_ASSERT ((insn & 0xff00) == 0xd100);
5554               insn = bfd_get_16 (input_bfd, contents + offset + 6);
5555               BFD_ASSERT (insn == 0x310c);
5556               insn = bfd_get_16 (input_bfd, contents + offset + 8);
5557               BFD_ASSERT (insn == 0x410b);
5558               insn = bfd_get_16 (input_bfd, contents + offset + 10);
5559               BFD_ASSERT (insn == 0x34cc);
5560
5561               bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5562               bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5563               bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5564               bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5565               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5566               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5567
5568               continue;
5569             }
5570
5571           sgot = htab->sgot;
5572           if (sgot == NULL)
5573             abort ();
5574
5575           off = htab->tls_ldm_got.offset;
5576           if (off & 1)
5577             off &= ~1;
5578           else
5579             {
5580               Elf_Internal_Rela outrel;
5581               Elf32_External_Rela *loc;
5582
5583               srelgot = htab->srelgot;
5584               if (srelgot == NULL)
5585                 abort ();
5586
5587               outrel.r_offset = (sgot->output_section->vma
5588                                  + sgot->output_offset + off);
5589               outrel.r_addend = 0;
5590               outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
5591               loc = (Elf32_External_Rela *) srelgot->contents;
5592               loc += srelgot->reloc_count++;
5593               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5594               htab->tls_ldm_got.offset |= 1;
5595             }
5596
5597           relocation = sgot->output_offset + off;
5598           addend = rel->r_addend;
5599
5600           goto final_link_relocate;
5601
5602         case R_SH_TLS_LDO_32:
5603           if (! info->shared)
5604             {
5605               int indx;
5606               Elf_Internal_Rela outrel;
5607
5608               if (sreloc == NULL)
5609                 {
5610                   const char *name;
5611
5612                   name = (bfd_elf_string_from_elf_section
5613                           (input_bfd,
5614                            elf_elfheader (input_bfd)->e_shstrndx,
5615                            elf_section_data (input_section)->rel_hdr.sh_name));
5616                   if (name == NULL)
5617                     return false;
5618
5619                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5620                               && strcmp (bfd_get_section_name (input_bfd,
5621                                                                input_section),
5622                                          name + 5) == 0);
5623
5624                   sreloc = bfd_get_section_by_name (dynobj, name);
5625                   BFD_ASSERT (sreloc != NULL);
5626                 }
5627
5628               indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5629               outrel.r_offset = (input_section->output_section->vma
5630                                  + input_section->output_offset
5631                                  + rel->r_offset);
5632               outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5633               if (indx == 0)
5634                 outrel.r_addend = relocation - dtpoff_base (info);
5635               else
5636                 outrel.r_addend = 0;
5637               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
5638                                          (((Elf32_External_Rela *)
5639                                            sreloc->contents)
5640                                           + sreloc->reloc_count));
5641               ++sreloc->reloc_count;
5642
5643               continue;
5644             }
5645           else
5646             relocation -= dtpoff_base (info);
5647
5648           addend = rel->r_addend;
5649           goto final_link_relocate;
5650
5651         case R_SH_TLS_LE_32:
5652           {
5653             int indx;
5654             Elf_Internal_Rela outrel;
5655
5656             if (sreloc == NULL)
5657               {
5658                 const char *name;
5659
5660                 name = (bfd_elf_string_from_elf_section
5661                         (input_bfd,
5662                          elf_elfheader (input_bfd)->e_shstrndx,
5663                          elf_section_data (input_section)->rel_hdr.sh_name));
5664                 if (name == NULL)
5665                   return false;
5666
5667                 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5668                             && strcmp (bfd_get_section_name (input_bfd,
5669                                                              input_section),
5670                                        name + 5) == 0);
5671
5672                 sreloc = bfd_get_section_by_name (dynobj, name);
5673                 BFD_ASSERT (sreloc != NULL);
5674               }
5675
5676             indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5677             outrel.r_offset = (input_section->output_section->vma
5678                                + input_section->output_offset
5679                                + rel->r_offset);
5680             outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5681             if (indx == 0)
5682               outrel.r_addend = relocation - dtpoff_base (info);
5683             else
5684               outrel.r_addend = 0;
5685             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
5686                                        (((Elf32_External_Rela *)
5687                                          sreloc->contents)
5688                                         + sreloc->reloc_count));
5689             ++sreloc->reloc_count;
5690
5691             continue;
5692           }
5693         }
5694
5695     relocation_done:
5696       if (r != bfd_reloc_ok)
5697         {
5698           switch (r)
5699             {
5700             default:
5701             case bfd_reloc_outofrange:
5702               abort ();
5703             case bfd_reloc_overflow:
5704               {
5705                 const char *name;
5706
5707                 if (h != NULL)
5708                   name = h->root.root.string;
5709                 else
5710                   {
5711                     name = (bfd_elf_string_from_elf_section
5712                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
5713                     if (name == NULL)
5714                       return false;
5715                     if (*name == '\0')
5716                       name = bfd_section_name (input_bfd, sec);
5717                   }
5718                 if (! ((*info->callbacks->reloc_overflow)
5719                        (info, name, howto->name, (bfd_vma) 0,
5720                         input_bfd, input_section, rel->r_offset)))
5721                   return false;
5722               }
5723               break;
5724             }
5725         }
5726     }
5727
5728   return true;
5729 }
5730
5731 /* This is a version of bfd_generic_get_relocated_section_contents
5732    which uses sh_elf_relocate_section.  */
5733
5734 static bfd_byte *
5735 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
5736                                        data, relocateable, symbols)
5737      bfd *output_bfd;
5738      struct bfd_link_info *link_info;
5739      struct bfd_link_order *link_order;
5740      bfd_byte *data;
5741      boolean relocateable;
5742      asymbol **symbols;
5743 {
5744   Elf_Internal_Shdr *symtab_hdr;
5745   asection *input_section = link_order->u.indirect.section;
5746   bfd *input_bfd = input_section->owner;
5747   asection **sections = NULL;
5748   Elf_Internal_Rela *internal_relocs = NULL;
5749   Elf_Internal_Sym *isymbuf = NULL;
5750
5751   /* We only need to handle the case of relaxing, or of having a
5752      particular set of section contents, specially.  */
5753   if (relocateable
5754       || elf_section_data (input_section)->this_hdr.contents == NULL)
5755     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5756                                                        link_order, data,
5757                                                        relocateable,
5758                                                        symbols);
5759
5760   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5761
5762   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5763           (size_t) input_section->_raw_size);
5764
5765   if ((input_section->flags & SEC_RELOC) != 0
5766       && input_section->reloc_count > 0)
5767     {
5768       asection **secpp;
5769       Elf_Internal_Sym *isym, *isymend;
5770       bfd_size_type amt;
5771
5772       internal_relocs = (_bfd_elf32_link_read_relocs
5773                          (input_bfd, input_section, (PTR) NULL,
5774                           (Elf_Internal_Rela *) NULL, false));
5775       if (internal_relocs == NULL)
5776         goto error_return;
5777
5778       if (symtab_hdr->sh_info != 0)
5779         {
5780           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5781           if (isymbuf == NULL)
5782             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5783                                             symtab_hdr->sh_info, 0,
5784                                             NULL, NULL, NULL);
5785           if (isymbuf == NULL)
5786             goto error_return;
5787         }
5788
5789       amt = symtab_hdr->sh_info;
5790       amt *= sizeof (asection *);
5791       sections = (asection **) bfd_malloc (amt);
5792       if (sections == NULL && amt != 0)
5793         goto error_return;
5794
5795       isymend = isymbuf + symtab_hdr->sh_info;
5796       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5797         {
5798           asection *isec;
5799
5800           if (isym->st_shndx == SHN_UNDEF)
5801             isec = bfd_und_section_ptr;
5802           else if (isym->st_shndx == SHN_ABS)
5803             isec = bfd_abs_section_ptr;
5804           else if (isym->st_shndx == SHN_COMMON)
5805             isec = bfd_com_section_ptr;
5806           else
5807             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5808
5809           *secpp = isec;
5810         }
5811
5812       if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5813                                      input_section, data, internal_relocs,
5814                                      isymbuf, sections))
5815         goto error_return;
5816
5817       if (sections != NULL)
5818         free (sections);
5819       if (isymbuf != NULL
5820           && symtab_hdr->contents != (unsigned char *) isymbuf)
5821         free (isymbuf);
5822       if (elf_section_data (input_section)->relocs != internal_relocs)
5823         free (internal_relocs);
5824     }
5825
5826   return data;
5827
5828  error_return:
5829   if (sections != NULL)
5830     free (sections);
5831   if (isymbuf != NULL
5832       && symtab_hdr->contents != (unsigned char *) isymbuf)
5833     free (isymbuf);
5834   if (internal_relocs != NULL
5835       && elf_section_data (input_section)->relocs != internal_relocs)
5836     free (internal_relocs);
5837   return NULL;
5838 }
5839
5840 /* Return the base VMA address which should be subtracted from real addresses
5841    when resolving @dtpoff relocation.
5842    This is PT_TLS segment p_vaddr.  */
5843
5844 static bfd_vma
5845 dtpoff_base (info)
5846      struct bfd_link_info *info;
5847 {
5848  /* If tls_segment is NULL, we should have signalled an error already.  */
5849  if (elf_hash_table (info)->tls_segment == NULL)
5850    return 0;
5851   return elf_hash_table (info)->tls_segment->start;
5852 }
5853
5854 static asection *
5855 sh_elf_gc_mark_hook (sec, info, rel, h, sym)
5856      asection *sec;
5857      struct bfd_link_info *info ATTRIBUTE_UNUSED;
5858      Elf_Internal_Rela *rel;
5859      struct elf_link_hash_entry *h;
5860      Elf_Internal_Sym *sym;
5861 {
5862   if (h != NULL)
5863     {
5864       switch (ELF32_R_TYPE (rel->r_info))
5865         {
5866         case R_SH_GNU_VTINHERIT:
5867         case R_SH_GNU_VTENTRY:
5868           break;
5869
5870         default:
5871 #ifdef INCLUDE_SHMEDIA
5872           while (h->root.type == bfd_link_hash_indirect
5873                  && h->root.u.i.link)
5874             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5875 #endif
5876           switch (h->root.type)
5877             {
5878             case bfd_link_hash_defined:
5879             case bfd_link_hash_defweak:
5880               return h->root.u.def.section;
5881
5882             case bfd_link_hash_common:
5883               return h->root.u.c.p->section;
5884
5885             default:
5886               break;
5887             }
5888         }
5889     }
5890   else
5891     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5892
5893   return NULL;
5894 }
5895
5896 /* Update the got entry reference counts for the section being removed.  */
5897
5898 static boolean
5899 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
5900      bfd *abfd;
5901      struct bfd_link_info *info;
5902      asection *sec;
5903      const Elf_Internal_Rela *relocs;
5904 {
5905   Elf_Internal_Shdr *symtab_hdr;
5906   struct elf_link_hash_entry **sym_hashes;
5907   bfd_signed_vma *local_got_refcounts;
5908   const Elf_Internal_Rela *rel, *relend;
5909   unsigned long r_symndx;
5910   struct elf_link_hash_entry *h;
5911   struct elf_sh_link_hash_entry *eh;
5912
5913   elf_section_data (sec)->local_dynrel = NULL;
5914
5915   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5916   sym_hashes = elf_sym_hashes (abfd);
5917   local_got_refcounts = elf_local_got_refcounts (abfd);
5918
5919   relend = relocs + sec->reloc_count;
5920   for (rel = relocs; rel < relend; rel++)
5921     {
5922 #ifdef INCLUDE_SHMEDIA
5923       int seen_stt_datalabel = 0;
5924 #endif
5925
5926       r_symndx = ELF32_R_SYM (rel->r_info);
5927       if (r_symndx < symtab_hdr->sh_info)
5928         h = NULL;
5929       else
5930         {
5931           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5932 #ifdef INCLUDE_SHMEDIA
5933           while (h->root.type == bfd_link_hash_indirect
5934                  || h->root.type == bfd_link_hash_warning)
5935             {
5936               seen_stt_datalabel |= h->type == STT_DATALABEL;
5937               h = (struct elf_link_hash_entry *) h->root.u.i.link;
5938             }
5939 #endif
5940         }
5941       eh = (struct elf_sh_link_hash_entry *) h;
5942
5943       switch (sh_elf_optimized_tls_reloc (info, ELF32_R_TYPE (rel->r_info),
5944                                           ELF32_R_SYM (rel->r_info)
5945                                           >= symtab_hdr->sh_info))
5946         {
5947         case R_SH_TLS_LD_32:
5948           if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0)
5949             sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
5950           break;
5951
5952         case R_SH_GOT32:
5953         case R_SH_GOTOFF:
5954         case R_SH_GOTPC:
5955 #ifdef INCLUDE_SHMEDIA
5956         case R_SH_GOT_LOW16:
5957         case R_SH_GOT_MEDLOW16:
5958         case R_SH_GOT_MEDHI16:
5959         case R_SH_GOT_HI16:
5960         case R_SH_GOT10BY4:
5961         case R_SH_GOT10BY8:
5962         case R_SH_GOTOFF_LOW16:
5963         case R_SH_GOTOFF_MEDLOW16:
5964         case R_SH_GOTOFF_MEDHI16:
5965         case R_SH_GOTOFF_HI16:
5966         case R_SH_GOTPC_LOW16:
5967         case R_SH_GOTPC_MEDLOW16:
5968         case R_SH_GOTPC_MEDHI16:
5969         case R_SH_GOTPC_HI16:
5970 #endif
5971         case R_SH_TLS_GD_32:
5972         case R_SH_TLS_IE_32:
5973           if (h != NULL)
5974             {
5975 #ifdef INCLUDE_SHMEDIA
5976               if (seen_stt_datalabel)
5977                 {
5978                   if (eh->datalabel_got.refcount > 0)
5979                     eh->datalabel_got.refcount -= 1;
5980                 }
5981               else
5982 #endif
5983                 if (h->got.refcount > 0)
5984                   h->got.refcount -= 1;
5985             }
5986           else if (local_got_refcounts != NULL)
5987             {
5988 #ifdef INCLUDE_SHMEDIA
5989               if (rel->r_addend & 1)
5990                 {
5991                   if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
5992                     local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
5993                 }
5994               else
5995 #endif
5996                 if (local_got_refcounts[r_symndx] > 0)
5997                   local_got_refcounts[r_symndx] -= 1;
5998             }
5999           break;
6000
6001         case R_SH_DIR32:
6002         case R_SH_REL32:
6003           if (h != NULL)
6004             {
6005               struct elf_sh_dyn_relocs **pp;
6006               struct elf_sh_dyn_relocs *p;
6007
6008
6009               if (!info->shared && h->plt.refcount > 0)
6010                 h->plt.refcount -= 1;
6011
6012               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6013                 if (p->sec == sec)
6014                   {
6015                     if (ELF32_R_TYPE (rel->r_info) == R_SH_REL32)
6016                       p->pc_count -= 1;
6017                     p->count -= 1;
6018                     if (p->count == 0)
6019                       *pp = p->next;
6020                     break;
6021                   }
6022             }
6023           break;
6024
6025         case R_SH_PLT32:
6026 #ifdef INCLUDE_SHMEDIA
6027         case R_SH_PLT_LOW16:
6028         case R_SH_PLT_MEDLOW16:
6029         case R_SH_PLT_MEDHI16:
6030         case R_SH_PLT_HI16:
6031 #endif
6032           if (h != NULL)
6033             {
6034               if (h->plt.refcount > 0)
6035                 h->plt.refcount -= 1;
6036             }
6037           break;
6038
6039         case R_SH_GOTPLT32:
6040 #ifdef INCLUDE_SHMEDIA
6041         case R_SH_GOTPLT_LOW16:
6042         case R_SH_GOTPLT_MEDLOW16:
6043         case R_SH_GOTPLT_MEDHI16:
6044         case R_SH_GOTPLT_HI16:
6045         case R_SH_GOTPLT10BY4:
6046         case R_SH_GOTPLT10BY8:
6047 #endif
6048           if (h != NULL)
6049             {
6050               if (eh->gotplt_refcount > 0)
6051                 {
6052                   eh->gotplt_refcount -= 1;
6053                   if (h->plt.refcount > 0)
6054                     h->plt.refcount -= 1;
6055                 }
6056 #ifdef INCLUDE_SHMEDIA
6057               else if (seen_stt_datalabel)
6058                 {
6059                   if (eh->datalabel_got.refcount > 0)
6060                     eh->datalabel_got.refcount -= 1;
6061                 }
6062 #endif
6063               else if (h->got.refcount > 0)
6064                 h->got.refcount -= 1;
6065             }
6066           else if (local_got_refcounts != NULL)
6067             {
6068 #ifdef INCLUDE_SHMEDIA
6069               if (rel->r_addend & 1)
6070                 {
6071                   if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
6072                     local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
6073                 }
6074               else
6075 #endif
6076                 if (local_got_refcounts[r_symndx] > 0)
6077                   local_got_refcounts[r_symndx] -= 1;
6078             }
6079           break;
6080
6081         default:
6082           break;
6083         }
6084     }
6085
6086   return true;
6087 }
6088
6089 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
6090
6091 static void
6092 sh_elf_copy_indirect_symbol (bed, dir, ind)
6093      struct elf_backend_data *bed;
6094      struct elf_link_hash_entry *dir, *ind;
6095 {
6096   struct elf_sh_link_hash_entry *edir, *eind;
6097 #ifdef INCLUDE_SHMEDIA
6098   bfd_signed_vma tmp;
6099 #endif
6100
6101   edir = (struct elf_sh_link_hash_entry *) dir;
6102   eind = (struct elf_sh_link_hash_entry *) ind;
6103
6104   if (eind->dyn_relocs != NULL)
6105     {
6106       if (edir->dyn_relocs != NULL)
6107         {
6108           struct elf_sh_dyn_relocs **pp;
6109           struct elf_sh_dyn_relocs *p;
6110
6111           BFD_ASSERT (ind->root.type != bfd_link_hash_indirect);
6112
6113           /* Add reloc counts against the weak sym to the strong sym
6114              list.  Merge any entries against the same section.  */
6115           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
6116             {
6117               struct elf_sh_dyn_relocs *q;
6118
6119               for (q = edir->dyn_relocs; q != NULL; q = q->next)
6120                 if (q->sec == p->sec)
6121                   {
6122                     q->pc_count += p->pc_count;
6123                     q->count += p->count;
6124                     *pp = p->next;
6125                     break;
6126                   }
6127               if (q == NULL)
6128                 pp = &p->next;
6129             }
6130           *pp = edir->dyn_relocs;
6131         }
6132
6133       edir->dyn_relocs = eind->dyn_relocs;
6134       eind->dyn_relocs = NULL;
6135     }
6136   edir->gotplt_refcount = eind->gotplt_refcount;
6137   eind->gotplt_refcount = 0;
6138 #ifdef INCLUDE_SHMEDIA
6139   tmp = edir->datalabel_got.refcount;
6140   if (tmp < 1)
6141     {
6142       edir->datalabel_got.refcount = eind->datalabel_got.refcount;
6143       eind->datalabel_got.refcount = tmp;
6144     }
6145   else
6146     BFD_ASSERT (eind->datalabel_got.refcount < 1);
6147 #endif
6148
6149   if (ind->root.type == bfd_link_hash_indirect
6150       && dir->got.refcount <= 0)
6151     {
6152       edir->tls_type = eind->tls_type;
6153       eind->tls_type = GOT_UNKNOWN;
6154     }
6155
6156   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
6157 }
6158
6159 static int
6160 sh_elf_optimized_tls_reloc (info, r_type, is_local)
6161      struct bfd_link_info *info;
6162      int r_type;
6163      int is_local;
6164 {
6165   if (info->shared)
6166     return r_type;
6167
6168   switch (r_type)
6169     {
6170     case R_SH_TLS_GD_32:
6171     case R_SH_TLS_IE_32:
6172       if (is_local)
6173         return R_SH_TLS_LE_32;
6174       return R_SH_TLS_IE_32;
6175     case R_SH_TLS_LD_32:
6176       return R_SH_TLS_LE_32;
6177     }
6178
6179   return r_type;
6180 }
6181
6182 /* Look through the relocs for a section during the first phase.
6183    Since we don't do .gots or .plts, we just need to consider the
6184    virtual table relocs for gc.  */
6185
6186 static boolean
6187 sh_elf_check_relocs (abfd, info, sec, relocs)
6188      bfd *abfd;
6189      struct bfd_link_info *info;
6190      asection *sec;
6191      const Elf_Internal_Rela *relocs;
6192 {
6193   Elf_Internal_Shdr *symtab_hdr;
6194   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6195   struct elf_sh_link_hash_table *htab;
6196   const Elf_Internal_Rela *rel;
6197   const Elf_Internal_Rela *rel_end;
6198   bfd *dynobj;
6199   bfd_vma *local_got_offsets;
6200   asection *sgot;
6201   asection *srelgot;
6202   asection *sreloc;
6203   unsigned int r_type;
6204   int tls_type, old_tls_type;
6205
6206   sgot = NULL;
6207   srelgot = NULL;
6208   sreloc = NULL;
6209
6210   if (info->relocateable)
6211     return true;
6212
6213   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6214   sym_hashes = elf_sym_hashes (abfd);
6215   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
6216   if (!elf_bad_symtab (abfd))
6217     sym_hashes_end -= symtab_hdr->sh_info;
6218
6219   htab = sh_elf_hash_table (info);
6220   dynobj = htab->root.dynobj;
6221   local_got_offsets = elf_local_got_offsets (abfd);
6222
6223   rel_end = relocs + sec->reloc_count;
6224   for (rel = relocs; rel < rel_end; rel++)
6225     {
6226       struct elf_link_hash_entry *h;
6227       unsigned long r_symndx;
6228 #ifdef INCLUDE_SHMEDIA
6229       int seen_stt_datalabel = 0;
6230 #endif
6231
6232       r_symndx = ELF32_R_SYM (rel->r_info);
6233       r_type = ELF32_R_TYPE (rel->r_info);
6234
6235       if (r_symndx < symtab_hdr->sh_info)
6236         h = NULL;
6237       else
6238         {
6239           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6240 #ifdef INCLUDE_SHMEDIA
6241           while (h->root.type == bfd_link_hash_indirect
6242                  || h->root.type == bfd_link_hash_warning)
6243             {
6244               seen_stt_datalabel |= h->type == STT_DATALABEL;
6245               h = (struct elf_link_hash_entry *) h->root.u.i.link;
6246             }
6247 #endif
6248         }
6249
6250       r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
6251       if (! info->shared
6252           && r_type == R_SH_TLS_IE_32
6253           && h != NULL
6254           && h->root.type != bfd_link_hash_undefined
6255           && h->root.type != bfd_link_hash_undefweak
6256           && (h->dynindx == -1
6257               || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
6258         r_type = R_SH_TLS_LE_32;
6259
6260       /* Some relocs require a global offset table.  */
6261       if (htab->sgot == NULL)
6262         {
6263           switch (r_type)
6264             {
6265             case R_SH_GOTPLT32:
6266             case R_SH_GOT32:
6267             case R_SH_GOTOFF:
6268             case R_SH_GOTPC:
6269 #ifdef INCLUDE_SHMEDIA
6270             case R_SH_GOTPLT_LOW16:
6271             case R_SH_GOTPLT_MEDLOW16:
6272             case R_SH_GOTPLT_MEDHI16:
6273             case R_SH_GOTPLT_HI16:
6274             case R_SH_GOTPLT10BY4:
6275             case R_SH_GOTPLT10BY8:
6276             case R_SH_GOT_LOW16:
6277             case R_SH_GOT_MEDLOW16:
6278             case R_SH_GOT_MEDHI16:
6279             case R_SH_GOT_HI16:
6280             case R_SH_GOT10BY4:
6281             case R_SH_GOT10BY8:
6282             case R_SH_GOTOFF_LOW16:
6283             case R_SH_GOTOFF_MEDLOW16:
6284             case R_SH_GOTOFF_MEDHI16:
6285             case R_SH_GOTOFF_HI16:
6286             case R_SH_GOTPC_LOW16:
6287             case R_SH_GOTPC_MEDLOW16:
6288             case R_SH_GOTPC_MEDHI16:
6289             case R_SH_GOTPC_HI16:
6290 #endif
6291             case R_SH_TLS_GD_32:
6292             case R_SH_TLS_LD_32:
6293             case R_SH_TLS_IE_32:
6294               if (dynobj == NULL)
6295                 htab->root.dynobj = dynobj = abfd;
6296               if (! create_got_section (dynobj, info))
6297                 return false;
6298               break;
6299
6300             default:
6301               break;
6302             }
6303         }
6304
6305       switch (r_type)
6306         {
6307           /* This relocation describes the C++ object vtable hierarchy.
6308              Reconstruct it for later use during GC.  */
6309         case R_SH_GNU_VTINHERIT:
6310           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6311             return false;
6312           break;
6313
6314           /* This relocation describes which C++ vtable entries are actually
6315              used.  Record for later use during GC.  */
6316         case R_SH_GNU_VTENTRY:
6317           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6318             return false;
6319           break;
6320
6321         force_got:
6322         case R_SH_TLS_IE_32:
6323           if (info->shared)
6324             info->flags |= DF_STATIC_TLS;
6325
6326           /* FALLTHROUGH */
6327         case R_SH_TLS_GD_32:
6328         case R_SH_GOT32:
6329 #ifdef INCLUDE_SHMEDIA
6330         case R_SH_GOT_LOW16:
6331         case R_SH_GOT_MEDLOW16:
6332         case R_SH_GOT_MEDHI16:
6333         case R_SH_GOT_HI16:
6334         case R_SH_GOT10BY4:
6335         case R_SH_GOT10BY8:
6336 #endif
6337           switch (r_type)
6338             {
6339             default:
6340               tls_type = GOT_NORMAL;
6341               break;
6342             case R_SH_TLS_GD_32:
6343               tls_type = GOT_TLS_GD;
6344               break;
6345             case R_SH_TLS_IE_32:
6346               tls_type = GOT_TLS_IE;
6347               break;
6348             }
6349
6350           if (h != NULL)
6351             {
6352 #ifdef INCLUDE_SHMEDIA
6353               if (seen_stt_datalabel)
6354                 {
6355                   struct elf_sh_link_hash_entry *eh =
6356                     (struct elf_sh_link_hash_entry *)h;
6357
6358                   eh->datalabel_got.refcount += 1;
6359                 }
6360               else
6361 #endif
6362                 h->got.refcount += 1;
6363               old_tls_type = sh_elf_hash_entry (h)->tls_type;
6364             }
6365           else
6366             {
6367               bfd_signed_vma *local_got_refcounts;
6368
6369               /* This is a global offset table entry for a local
6370                  symbol.  */
6371               local_got_refcounts = elf_local_got_refcounts (abfd);
6372               if (local_got_refcounts == NULL)
6373                 {
6374                   bfd_size_type size;
6375
6376                   size = symtab_hdr->sh_info;
6377                   size *= sizeof (bfd_signed_vma);
6378 #ifdef INCLUDE_SHMEDIA
6379                   /* Reserve space for both the datalabel and
6380                      codelabel local GOT offsets.  */
6381                   size *= 2;
6382 #endif
6383                   size += symtab_hdr->sh_info;
6384                   local_got_refcounts = ((bfd_signed_vma *)
6385                                          bfd_zalloc (abfd, size));
6386                   if (local_got_refcounts == NULL)
6387                     return false;
6388                   elf_local_got_refcounts (abfd) = local_got_refcounts;
6389 #ifdef  INCLUDE_SHMEDIA
6390                   /* Take care of both the datalabel and codelabel local
6391                      GOT offsets.  */
6392                   sh_elf_local_got_tls_type (abfd)
6393                     = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
6394 #else
6395                   sh_elf_local_got_tls_type (abfd)
6396                     = (char *) (local_got_refcounts + symtab_hdr->sh_info);
6397 #endif
6398                 }
6399 #ifdef INCLUDE_SHMEDIA
6400               if (rel->r_addend & 1)
6401                 local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
6402               else
6403 #endif
6404                 local_got_refcounts[r_symndx] += 1;
6405               old_tls_type = sh_elf_local_got_tls_type (abfd) [r_symndx];
6406             }
6407
6408           /* If a TLS symbol is accessed using IE at least once,
6409              there is no point to use dynamic model for it.  */
6410           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
6411               && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
6412             {
6413               if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
6414                 tls_type = GOT_TLS_IE;
6415               else
6416                 {
6417                   (*_bfd_error_handler)
6418                     (_("%s: `%s' accessed both as normal and thread local symbol"),
6419                      bfd_archive_filename (abfd), h->root.root.string);
6420                   return false;
6421                 }
6422             }
6423
6424           if (old_tls_type != tls_type)
6425             {
6426               if (h != NULL)
6427                 sh_elf_hash_entry (h)->tls_type = tls_type;
6428               else
6429                 sh_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
6430             }
6431
6432           break;
6433
6434         case R_SH_TLS_LD_32:
6435           sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
6436           break;
6437
6438         case R_SH_GOTPLT32:
6439 #ifdef INCLUDE_SHMEDIA
6440         case R_SH_GOTPLT_LOW16:
6441         case R_SH_GOTPLT_MEDLOW16:
6442         case R_SH_GOTPLT_MEDHI16:
6443         case R_SH_GOTPLT_HI16:
6444         case R_SH_GOTPLT10BY4:
6445         case R_SH_GOTPLT10BY8:
6446 #endif
6447           /* If this is a local symbol, we resolve it directly without
6448              creating a procedure linkage table entry.  */
6449
6450           if (h == NULL
6451               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
6452               || ! info->shared
6453               || info->symbolic
6454               || h->dynindx == -1)
6455             goto force_got;
6456
6457           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
6458           h->plt.refcount += 1;
6459           ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
6460
6461           break;
6462
6463         case R_SH_PLT32:
6464 #ifdef INCLUDE_SHMEDIA
6465         case R_SH_PLT_LOW16:
6466         case R_SH_PLT_MEDLOW16:
6467         case R_SH_PLT_MEDHI16:
6468         case R_SH_PLT_HI16:
6469 #endif
6470           /* This symbol requires a procedure linkage table entry.  We
6471              actually build the entry in adjust_dynamic_symbol,
6472              because this might be a case of linking PIC code which is
6473              never referenced by a dynamic object, in which case we
6474              don't need to generate a procedure linkage table entry
6475              after all.  */
6476
6477           /* If this is a local symbol, we resolve it directly without
6478              creating a procedure linkage table entry.  */
6479           if (h == NULL)
6480             continue;
6481
6482           if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
6483             break;
6484
6485           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
6486           h->plt.refcount += 1;
6487           break;
6488
6489         case R_SH_DIR32:
6490         case R_SH_REL32:
6491           if (h != NULL && ! info->shared)
6492             {
6493               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
6494               h->plt.refcount += 1;
6495             }
6496
6497           /* If we are creating a shared library, and this is a reloc
6498              against a global symbol, or a non PC relative reloc
6499              against a local symbol, then we need to copy the reloc
6500              into the shared library.  However, if we are linking with
6501              -Bsymbolic, we do not need to copy a reloc against a
6502              global symbol which is defined in an object we are
6503              including in the link (i.e., DEF_REGULAR is set).  At
6504              this point we have not seen all the input files, so it is
6505              possible that DEF_REGULAR is not set now but will be set
6506              later (it is never cleared).  We account for that
6507              possibility below by storing information in the
6508              dyn_relocs field of the hash table entry. A similar
6509              situation occurs when creating shared libraries and symbol
6510              visibility changes render the symbol local.
6511
6512              If on the other hand, we are creating an executable, we
6513              may need to keep relocations for symbols satisfied by a
6514              dynamic library if we manage to avoid copy relocs for the
6515              symbol.  */
6516           if ((info->shared
6517                && (sec->flags & SEC_ALLOC) != 0
6518                && (r_type != R_SH_REL32
6519                    || (h != NULL
6520                        && (! info->symbolic
6521                            || h->root.type == bfd_link_hash_defweak
6522                            || (h->elf_link_hash_flags
6523                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
6524               || (! info->shared
6525                   && (sec->flags & SEC_ALLOC) != 0
6526                   && h != NULL
6527                   && (h->root.type == bfd_link_hash_defweak
6528                       || (h->elf_link_hash_flags
6529                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6530             {
6531               struct elf_sh_dyn_relocs *p;
6532               struct elf_sh_dyn_relocs **head;
6533
6534               if (dynobj == NULL)
6535                 htab->root.dynobj = dynobj = abfd;
6536
6537               /* When creating a shared object, we must copy these
6538                  reloc types into the output file.  We create a reloc
6539                  section in dynobj and make room for this reloc.  */
6540               if (sreloc == NULL)
6541                 {
6542                   const char *name;
6543
6544                   name = (bfd_elf_string_from_elf_section
6545                           (abfd,
6546                            elf_elfheader (abfd)->e_shstrndx,
6547                            elf_section_data (sec)->rel_hdr.sh_name));
6548                   if (name == NULL)
6549                     return false;
6550
6551                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6552                               && strcmp (bfd_get_section_name (abfd, sec),
6553                                          name + 5) == 0);
6554
6555                   sreloc = bfd_get_section_by_name (dynobj, name);
6556                   if (sreloc == NULL)
6557                     {
6558                       flagword flags;
6559
6560                       sreloc = bfd_make_section (dynobj, name);
6561                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
6562                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6563                       if ((sec->flags & SEC_ALLOC) != 0)
6564                         flags |= SEC_ALLOC | SEC_LOAD;
6565                       if (sreloc == NULL
6566                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
6567                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6568                         return false;
6569                     }
6570                   if (sec->flags & SEC_READONLY)
6571                     info->flags |= DF_TEXTREL;
6572                   elf_section_data (sec)->sreloc = sreloc;
6573                 }
6574
6575               /* If this is a global symbol, we count the number of
6576                  relocations we need for this symbol.  */
6577               if (h != NULL)
6578                 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6579               else
6580                 {
6581                   asection *s;
6582
6583                   /* Track dynamic relocs needed for local syms too.  */
6584                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6585                                                  sec, r_symndx);
6586                   if (s == NULL)
6587                     return false;
6588
6589                   head = ((struct elf_sh_dyn_relocs **)
6590                           &elf_section_data (s)->local_dynrel);
6591                 }
6592
6593               p = *head;
6594               if (p == NULL || p->sec != sec)
6595                 {
6596                   bfd_size_type amt = sizeof (*p);
6597                   p = ((struct elf_sh_dyn_relocs *) bfd_alloc (dynobj, amt));
6598                   if (p == NULL)
6599                     return false;
6600                   p->next = *head;
6601                   *head = p;
6602                   p->sec = sec;
6603                   p->count = 0;
6604                   p->pc_count = 0;
6605                 }
6606
6607               p->count += 1;
6608               if (r_type == R_SH_REL32)
6609                 p->pc_count += 1;
6610             }
6611
6612           break;
6613
6614         case R_SH_TLS_LE_32:
6615           if (info->shared)
6616             {
6617               (*_bfd_error_handler) (_("%s: TLS local exec code cannot be linked into shared objects"),
6618                                      bfd_archive_filename (abfd));
6619               return false;
6620             }
6621
6622           if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_LD_32)
6623             break;
6624
6625           /* FALLTHROUGH */
6626         case R_SH_TLS_LDO_32:
6627           /* We make a R_SH_TLS_TPOFF32 relocation. Count it as a
6628              copy relocation.  */
6629           if (! info->shared)
6630             {
6631               struct elf_sh_dyn_relocs *p;
6632               struct elf_sh_dyn_relocs **head;
6633
6634               if (dynobj == NULL)
6635                 htab->root.dynobj = dynobj = abfd;
6636
6637               if (sreloc == NULL)
6638                 {
6639                   const char *name;
6640
6641                   name = (bfd_elf_string_from_elf_section
6642                           (abfd,
6643                            elf_elfheader (abfd)->e_shstrndx,
6644                            elf_section_data (sec)->rel_hdr.sh_name));
6645                   if (name == NULL)
6646                     return false;
6647
6648                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6649                               && strcmp (bfd_get_section_name (abfd, sec),
6650                                          name + 5) == 0);
6651
6652                   sreloc = bfd_get_section_by_name (dynobj, name);
6653                   if (sreloc == NULL)
6654                     {
6655                       flagword flags;
6656
6657                       sreloc = bfd_make_section (dynobj, name);
6658                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
6659                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6660                       if ((sec->flags & SEC_ALLOC) != 0)
6661                         flags |= SEC_ALLOC | SEC_LOAD;
6662                       if (sreloc == NULL
6663                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
6664                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6665                         return false;
6666                     }
6667                   elf_section_data (sec)->sreloc = sreloc;
6668                   if (sec->flags & SEC_READONLY)
6669                     info->flags |= DF_TEXTREL;
6670                 }
6671
6672               /* If this is a global symbol, we count the number of
6673                  relocations we need for this symbol.  */
6674               if (h != NULL)
6675                 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6676               else
6677                 {
6678                   asection *s;
6679
6680                   /* Track dynamic relocs needed for local syms too.  */
6681                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6682                                                  sec, r_symndx);
6683                   if (s == NULL)
6684                     return false;
6685
6686                   head = ((struct elf_sh_dyn_relocs **)
6687                           &elf_section_data (s)->local_dynrel);
6688                 }
6689
6690               p = *head;
6691               if (p == NULL || p->sec != sec)
6692                 {
6693                   bfd_size_type amt = sizeof (*p);
6694                   p = ((struct elf_sh_dyn_relocs *) bfd_alloc (dynobj, amt));
6695                   if (p == NULL)
6696                     return false;
6697                   p->next = *head;
6698                   *head = p;
6699                   p->sec = sec;
6700                   p->count = 0;
6701                   p->pc_count = 0;
6702                 }
6703
6704               p->count += 1;
6705               if (h)
6706                 sh_elf_hash_entry (h)->tls_tpoff32 = true;
6707             }
6708           break;
6709
6710         default:
6711           break;
6712         }
6713     }
6714
6715   return true;
6716 }
6717
6718 #ifndef sh_elf_set_mach_from_flags
6719 static boolean
6720 sh_elf_set_mach_from_flags (abfd)
6721      bfd *abfd;
6722 {
6723   flagword flags = elf_elfheader (abfd)->e_flags;
6724
6725   switch (flags & EF_SH_MACH_MASK)
6726     {
6727     case EF_SH1:
6728       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
6729       break;
6730     case EF_SH2:
6731       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
6732       break;
6733     case EF_SH_DSP:
6734       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
6735       break;
6736     case EF_SH3:
6737       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
6738       break;
6739     case EF_SH3_DSP:
6740       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
6741       break;
6742     case EF_SH3E:
6743       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
6744       break;
6745     case EF_SH_UNKNOWN:
6746     case EF_SH4:
6747       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
6748       break;
6749     default:
6750       return false;
6751     }
6752   return true;
6753 }
6754 #endif /* not sh_elf_set_mach_from_flags */
6755
6756 #ifndef sh_elf_set_private_flags
6757 /* Function to keep SH specific file flags.  */
6758
6759 static boolean
6760 sh_elf_set_private_flags (abfd, flags)
6761      bfd *abfd;
6762      flagword flags;
6763 {
6764   BFD_ASSERT (! elf_flags_init (abfd)
6765               || elf_elfheader (abfd)->e_flags == flags);
6766
6767   elf_elfheader (abfd)->e_flags = flags;
6768   elf_flags_init (abfd) = true;
6769   return sh_elf_set_mach_from_flags (abfd);
6770 }
6771 #endif /* not sh_elf_set_private_flags */
6772
6773 #ifndef sh_elf_copy_private_data
6774 /* Copy backend specific data from one object module to another */
6775
6776 static boolean
6777 sh_elf_copy_private_data (ibfd, obfd)
6778      bfd * ibfd;
6779      bfd * obfd;
6780 {
6781   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6782       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6783     return true;
6784
6785   return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
6786 }
6787 #endif /* not sh_elf_copy_private_data */
6788
6789 #ifndef sh_elf_merge_private_data
6790 /* This routine checks for linking big and little endian objects
6791    together, and for linking sh-dsp with sh3e / sh4 objects.  */
6792
6793 static boolean
6794 sh_elf_merge_private_data (ibfd, obfd)
6795      bfd *ibfd;
6796      bfd *obfd;
6797 {
6798   flagword old_flags, new_flags;
6799
6800   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
6801     return false;
6802
6803   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6804       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6805     return true;
6806
6807   if (! elf_flags_init (obfd))
6808     {
6809       /* This happens when ld starts out with a 'blank' output file.  */
6810       elf_flags_init (obfd) = true;
6811       elf_elfheader (obfd)->e_flags = EF_SH1;
6812     }
6813   old_flags = elf_elfheader (obfd)->e_flags;
6814   new_flags = elf_elfheader (ibfd)->e_flags;
6815   if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
6816       || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
6817     {
6818       (*_bfd_error_handler)
6819         ("%s: uses %s instructions while previous modules use %s instructions",
6820          bfd_archive_filename (ibfd),
6821          EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
6822          EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
6823       bfd_set_error (bfd_error_bad_value);
6824       return false;
6825     }
6826   elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
6827
6828   return sh_elf_set_mach_from_flags (obfd);
6829 }
6830 #endif /* not sh_elf_merge_private_data */
6831
6832 /* Override the generic function because we need to store sh_elf_obj_tdata
6833    as the specific tdata.  We set also the machine architecture from flags
6834    here.  */
6835
6836 static boolean
6837 sh_elf_object_p (abfd)
6838   bfd *abfd;
6839 {
6840   struct sh_elf_obj_tdata *new_tdata;
6841   bfd_size_type amt = sizeof (struct sh_elf_obj_tdata);
6842
6843   if (sh_elf_set_mach_from_flags (abfd) == false)
6844     return false;
6845
6846   /* Allocate our special target data.  */
6847   new_tdata = bfd_zalloc (abfd, amt);
6848   if (new_tdata == NULL)
6849     return false;
6850   new_tdata->root = *abfd->tdata.elf_obj_data;
6851   abfd->tdata.any = new_tdata;
6852   return true;
6853 }
6854
6855 /* Finish up dynamic symbol handling.  We set the contents of various
6856    dynamic sections here.  */
6857
6858 static boolean
6859 sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
6860      bfd *output_bfd;
6861      struct bfd_link_info *info;
6862      struct elf_link_hash_entry *h;
6863      Elf_Internal_Sym *sym;
6864 {
6865   struct elf_sh_link_hash_table *htab;
6866   bfd *dynobj;
6867
6868   htab = sh_elf_hash_table (info);
6869   dynobj = htab->root.dynobj;
6870
6871   if (h->plt.offset != (bfd_vma) -1)
6872     {
6873       asection *splt;
6874       asection *sgot;
6875       asection *srel;
6876
6877       bfd_vma plt_index;
6878       bfd_vma got_offset;
6879       Elf_Internal_Rela rel;
6880
6881       /* This symbol has an entry in the procedure linkage table.  Set
6882          it up.  */
6883
6884       BFD_ASSERT (h->dynindx != -1);
6885
6886       splt = htab->splt;
6887       sgot = htab->sgotplt;
6888       srel = htab->srelplt;
6889       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
6890
6891       /* Get the index in the procedure linkage table which
6892          corresponds to this symbol.  This is the index of this symbol
6893          in all the symbols for which we are making plt entries.  The
6894          first entry in the procedure linkage table is reserved.  */
6895       plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
6896
6897       /* Get the offset into the .got table of the entry that
6898          corresponds to this function.  Each .got entry is 4 bytes.
6899          The first three are reserved.  */
6900       got_offset = (plt_index + 3) * 4;
6901
6902 #ifdef GOT_BIAS
6903       if (info->shared)
6904         got_offset -= GOT_BIAS;
6905 #endif
6906
6907       /* Fill in the entry in the procedure linkage table.  */
6908       if (! info->shared)
6909         {
6910           if (elf_sh_plt_entry == NULL)
6911             {
6912               elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
6913                                   elf_sh_plt_entry_be : elf_sh_plt_entry_le);
6914             }
6915           memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
6916                   elf_sh_sizeof_plt (info));
6917 #ifdef INCLUDE_SHMEDIA
6918           movi_shori_putval (output_bfd,
6919                              (sgot->output_section->vma
6920                               + sgot->output_offset
6921                               + got_offset),
6922                              (splt->contents + h->plt.offset
6923                               + elf_sh_plt_symbol_offset (info)));
6924
6925           /* Set bottom bit because its for a branch to SHmedia */
6926           movi_shori_putval (output_bfd,
6927                              (splt->output_section->vma + splt->output_offset)
6928                              | 1,
6929                              (splt->contents + h->plt.offset
6930                               + elf_sh_plt_plt0_offset (info)));
6931 #else
6932           bfd_put_32 (output_bfd,
6933                       (sgot->output_section->vma
6934                        + sgot->output_offset
6935                        + got_offset),
6936                       (splt->contents + h->plt.offset
6937                        + elf_sh_plt_symbol_offset (info)));
6938
6939           bfd_put_32 (output_bfd,
6940                       (splt->output_section->vma + splt->output_offset),
6941                       (splt->contents + h->plt.offset
6942                        + elf_sh_plt_plt0_offset (info)));
6943 #endif
6944         }
6945       else
6946         {
6947           if (elf_sh_pic_plt_entry == NULL)
6948             {
6949               elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
6950                                       elf_sh_pic_plt_entry_be :
6951                                       elf_sh_pic_plt_entry_le);
6952             }
6953           memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
6954                   elf_sh_sizeof_plt (info));
6955 #ifdef INCLUDE_SHMEDIA
6956           movi_shori_putval (output_bfd, got_offset,
6957                              (splt->contents + h->plt.offset
6958                               + elf_sh_plt_symbol_offset (info)));
6959 #else
6960           bfd_put_32 (output_bfd, got_offset,
6961                       (splt->contents + h->plt.offset
6962                        + elf_sh_plt_symbol_offset (info)));
6963 #endif
6964         }
6965
6966 #ifdef GOT_BIAS
6967       if (info->shared)
6968         got_offset += GOT_BIAS;
6969 #endif
6970
6971 #ifdef INCLUDE_SHMEDIA
6972       movi_shori_putval (output_bfd,
6973                          plt_index * sizeof (Elf32_External_Rela),
6974                          (splt->contents + h->plt.offset
6975                           + elf_sh_plt_reloc_offset (info)));
6976 #else
6977       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
6978                   (splt->contents + h->plt.offset
6979                    + elf_sh_plt_reloc_offset (info)));
6980 #endif
6981
6982       /* Fill in the entry in the global offset table.  */
6983       bfd_put_32 (output_bfd,
6984                   (splt->output_section->vma
6985                    + splt->output_offset
6986                    + h->plt.offset
6987                    + elf_sh_plt_temp_offset (info)),
6988                   sgot->contents + got_offset);
6989
6990       /* Fill in the entry in the .rela.plt section.  */
6991       rel.r_offset = (sgot->output_section->vma
6992                       + sgot->output_offset
6993                       + got_offset);
6994       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
6995       rel.r_addend = 0;
6996 #ifdef GOT_BIAS
6997       rel.r_addend = GOT_BIAS;
6998 #endif
6999       bfd_elf32_swap_reloca_out (output_bfd, &rel,
7000                                 ((Elf32_External_Rela *) srel->contents
7001                                  + plt_index));
7002
7003       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
7004         {
7005           /* Mark the symbol as undefined, rather than as defined in
7006              the .plt section.  Leave the value alone.  */
7007           sym->st_shndx = SHN_UNDEF;
7008         }
7009     }
7010
7011   if (h->got.offset != (bfd_vma) -1
7012       && sh_elf_hash_entry (h)->tls_type != GOT_TLS_GD
7013       && sh_elf_hash_entry (h)->tls_type != GOT_TLS_IE)
7014     {
7015       asection *sgot;
7016       asection *srel;
7017       Elf_Internal_Rela rel;
7018
7019       /* This symbol has an entry in the global offset table.  Set it
7020          up.  */
7021
7022       sgot = htab->sgot;
7023       srel = htab->srelgot;
7024       BFD_ASSERT (sgot != NULL && srel != NULL);
7025
7026       rel.r_offset = (sgot->output_section->vma
7027                       + sgot->output_offset
7028                       + (h->got.offset &~ (bfd_vma) 1));
7029
7030       /* If this is a static link, or it is a -Bsymbolic link and the
7031          symbol is defined locally or was forced to be local because
7032          of a version file, we just want to emit a RELATIVE reloc.
7033          The entry in the global offset table will already have been
7034          initialized in the relocate_section function.  */
7035       if (info->shared
7036           && (info->symbolic
7037               || h->dynindx == -1
7038               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
7039           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
7040         {
7041           rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7042           rel.r_addend = (h->root.u.def.value
7043                           + h->root.u.def.section->output_section->vma
7044                           + h->root.u.def.section->output_offset);
7045         }
7046       else
7047         {
7048           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
7049           rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7050           rel.r_addend = 0;
7051         }
7052
7053       bfd_elf32_swap_reloca_out (output_bfd, &rel,
7054                                  ((Elf32_External_Rela *) srel->contents
7055                                   + srel->reloc_count));
7056       ++srel->reloc_count;
7057     }
7058
7059 #ifdef INCLUDE_SHMEDIA
7060   {
7061     struct elf_sh_link_hash_entry *eh;
7062
7063     eh = (struct elf_sh_link_hash_entry *) h;
7064     if (eh->datalabel_got.offset != (bfd_vma) -1)
7065       {
7066         asection *sgot;
7067         asection *srel;
7068         Elf_Internal_Rela rel;
7069
7070         /* This symbol has a datalabel entry in the global offset table.
7071            Set it up.  */
7072
7073         sgot = htab->sgot;
7074         srel = htab->srelgot;
7075         BFD_ASSERT (sgot != NULL && srel != NULL);
7076
7077         rel.r_offset = (sgot->output_section->vma
7078                         + sgot->output_offset
7079                         + (eh->datalabel_got.offset &~ (bfd_vma) 1));
7080
7081         /* If this is a static link, or it is a -Bsymbolic link and the
7082            symbol is defined locally or was forced to be local because
7083            of a version file, we just want to emit a RELATIVE reloc.
7084            The entry in the global offset table will already have been
7085            initialized in the relocate_section function.  */
7086         if (info->shared
7087             && (info->symbolic
7088                 || h->dynindx == -1
7089                 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
7090             && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
7091           {
7092             rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7093             rel.r_addend = (h->root.u.def.value
7094                             + h->root.u.def.section->output_section->vma
7095                             + h->root.u.def.section->output_offset);
7096           }
7097         else
7098           {
7099             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents
7100                         + eh->datalabel_got.offset);
7101             rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7102             rel.r_addend = 0;
7103           }
7104
7105         bfd_elf32_swap_reloca_out (output_bfd, &rel,
7106                                    ((Elf32_External_Rela *) srel->contents
7107                                     + srel->reloc_count));
7108         ++srel->reloc_count;
7109       }
7110   }
7111 #endif
7112
7113   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
7114     {
7115       asection *s;
7116       Elf_Internal_Rela rel;
7117
7118       /* This symbol needs a copy reloc.  Set it up.  */
7119
7120       BFD_ASSERT (h->dynindx != -1
7121                   && (h->root.type == bfd_link_hash_defined
7122                       || h->root.type == bfd_link_hash_defweak));
7123
7124       s = bfd_get_section_by_name (h->root.u.def.section->owner,
7125                                    ".rela.bss");
7126       BFD_ASSERT (s != NULL);
7127
7128       rel.r_offset = (h->root.u.def.value
7129                       + h->root.u.def.section->output_section->vma
7130                       + h->root.u.def.section->output_offset);
7131       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
7132       rel.r_addend = 0;
7133       bfd_elf32_swap_reloca_out (output_bfd, &rel,
7134                                  ((Elf32_External_Rela *) s->contents
7135                                   + s->reloc_count));
7136       ++s->reloc_count;
7137     }
7138
7139   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
7140   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7141       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7142     sym->st_shndx = SHN_ABS;
7143
7144   return true;
7145 }
7146
7147 /* Finish up the dynamic sections.  */
7148
7149 static boolean
7150 sh_elf_finish_dynamic_sections (output_bfd, info)
7151      bfd *output_bfd;
7152      struct bfd_link_info *info;
7153 {
7154   struct elf_sh_link_hash_table *htab;
7155   bfd *dynobj;
7156   asection *sgot;
7157   asection *sdyn;
7158
7159   htab = sh_elf_hash_table (info);
7160   dynobj = htab->root.dynobj;
7161
7162   sgot = htab->sgotplt;
7163   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7164
7165   if (htab->root.dynamic_sections_created)
7166     {
7167       asection *splt;
7168       Elf32_External_Dyn *dyncon, *dynconend;
7169
7170       BFD_ASSERT (sgot != NULL && sdyn != NULL);
7171
7172       dyncon = (Elf32_External_Dyn *) sdyn->contents;
7173       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
7174       for (; dyncon < dynconend; dyncon++)
7175         {
7176           Elf_Internal_Dyn dyn;
7177           asection *s;
7178 #ifdef INCLUDE_SHMEDIA
7179           const char *name;
7180 #endif
7181
7182           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
7183
7184           switch (dyn.d_tag)
7185             {
7186             default:
7187               break;
7188
7189 #ifdef INCLUDE_SHMEDIA
7190             case DT_INIT:
7191               name = info->init_function;
7192               goto get_sym;
7193
7194             case DT_FINI:
7195               name = info->fini_function;
7196             get_sym:
7197               if (dyn.d_un.d_val != 0)
7198                 {
7199                   struct elf_link_hash_entry *h;
7200
7201                   h = elf_link_hash_lookup (&htab->root, name,
7202                                             false, false, true);
7203                   if (h != NULL && (h->other & STO_SH5_ISA32))
7204                     {
7205                       dyn.d_un.d_val |= 1;
7206                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7207                     }
7208                 }
7209               break;
7210 #endif
7211
7212             case DT_PLTGOT:
7213               s = htab->sgot->output_section;
7214               goto get_vma;
7215
7216             case DT_JMPREL:
7217               s = htab->srelplt->output_section;
7218             get_vma:
7219               BFD_ASSERT (s != NULL);
7220               dyn.d_un.d_ptr = s->vma;
7221               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7222               break;
7223
7224             case DT_PLTRELSZ:
7225               s = htab->srelplt->output_section;
7226               BFD_ASSERT (s != NULL);
7227               if (s->_cooked_size != 0)
7228                 dyn.d_un.d_val = s->_cooked_size;
7229               else
7230                 dyn.d_un.d_val = s->_raw_size;
7231               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7232               break;
7233
7234             case DT_RELASZ:
7235               /* My reading of the SVR4 ABI indicates that the
7236                  procedure linkage table relocs (DT_JMPREL) should be
7237                  included in the overall relocs (DT_RELA).  This is
7238                  what Solaris does.  However, UnixWare can not handle
7239                  that case.  Therefore, we override the DT_RELASZ entry
7240                  here to make it not include the JMPREL relocs.  Since
7241                  the linker script arranges for .rela.plt to follow all
7242                  other relocation sections, we don't have to worry
7243                  about changing the DT_RELA entry.  */
7244               if (htab->srelplt != NULL)
7245                 {
7246                   s = htab->srelplt->output_section;
7247                   if (s->_cooked_size != 0)
7248                     dyn.d_un.d_val -= s->_cooked_size;
7249                   else
7250                     dyn.d_un.d_val -= s->_raw_size;
7251                 }
7252               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7253               break;
7254             }
7255         }
7256
7257       /* Fill in the first entry in the procedure linkage table.  */
7258       splt = htab->splt;
7259       if (splt && splt->_raw_size > 0)
7260         {
7261           if (info->shared)
7262             {
7263               if (elf_sh_pic_plt_entry == NULL)
7264                 {
7265                   elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
7266                                           elf_sh_pic_plt_entry_be :
7267                                           elf_sh_pic_plt_entry_le);
7268                 }
7269               memcpy (splt->contents, elf_sh_pic_plt_entry,
7270                       elf_sh_sizeof_plt (info));
7271             }
7272           else
7273             {
7274               if (elf_sh_plt0_entry == NULL)
7275                 {
7276                   elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
7277                                        elf_sh_plt0_entry_be :
7278                                        elf_sh_plt0_entry_le);
7279                 }
7280               memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
7281 #ifdef INCLUDE_SHMEDIA
7282               movi_shori_putval (output_bfd,
7283                                  sgot->output_section->vma
7284                                  + sgot->output_offset,
7285                                  splt->contents
7286                                  + elf_sh_plt0_gotplt_offset (info));
7287 #else
7288               bfd_put_32 (output_bfd,
7289                           sgot->output_section->vma + sgot->output_offset + 4,
7290                           splt->contents + elf_sh_plt0_gotid_offset (info));
7291               bfd_put_32 (output_bfd,
7292                           sgot->output_section->vma + sgot->output_offset + 8,
7293                           splt->contents + elf_sh_plt0_linker_offset (info));
7294 #endif
7295             }
7296
7297           /* UnixWare sets the entsize of .plt to 4, although that doesn't
7298              really seem like the right value.  */
7299           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7300         }
7301     }
7302
7303   /* Fill in the first three entries in the global offset table.  */
7304   if (sgot && sgot->_raw_size > 0)
7305     {
7306       if (sdyn == NULL)
7307         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7308       else
7309         bfd_put_32 (output_bfd,
7310                     sdyn->output_section->vma + sdyn->output_offset,
7311                     sgot->contents);
7312       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7313       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7314
7315       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7316     }
7317
7318   return true;
7319 }
7320
7321 static enum elf_reloc_type_class
7322 sh_elf_reloc_type_class (rela)
7323      const Elf_Internal_Rela *rela;
7324 {
7325   switch ((int) ELF32_R_TYPE (rela->r_info))
7326     {
7327     case R_SH_RELATIVE:
7328       return reloc_class_relative;
7329     case R_SH_JMP_SLOT:
7330       return reloc_class_plt;
7331     case R_SH_COPY:
7332       return reloc_class_copy;
7333     default:
7334       return reloc_class_normal;
7335     }
7336 }
7337
7338 /* Support for Linux core dump NOTE sections */
7339 static boolean
7340 elf32_shlin_grok_prstatus (abfd, note)
7341      bfd *abfd;
7342      Elf_Internal_Note *note;
7343 {
7344   int offset;
7345   unsigned int raw_size;
7346
7347   switch (note->descsz)
7348     {
7349       default:
7350         return false;
7351
7352       case 168:         /* Linux/SH */
7353         /* pr_cursig */
7354         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
7355
7356         /* pr_pid */
7357         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
7358
7359         /* pr_reg */
7360         offset = 72;
7361         raw_size = 92;
7362
7363         break;
7364     }
7365
7366   /* Make a ".reg/999" section.  */
7367   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7368                                           raw_size, note->descpos + offset);
7369 }
7370
7371 static boolean
7372 elf32_shlin_grok_psinfo (abfd, note)
7373      bfd *abfd;
7374      Elf_Internal_Note *note;
7375 {
7376   switch (note->descsz)
7377     {
7378       default:
7379         return false;
7380
7381       case 124:         /* Linux/SH elf_prpsinfo */
7382         elf_tdata (abfd)->core_program
7383          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
7384         elf_tdata (abfd)->core_command
7385          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
7386     }
7387
7388   /* Note that for some reason, a spurious space is tacked
7389      onto the end of the args in some (at least one anyway)
7390      implementations, so strip it off if it exists.  */
7391
7392   {
7393     char *command = elf_tdata (abfd)->core_command;
7394     int n = strlen (command);
7395
7396     if (0 < n && command[n - 1] == ' ')
7397       command[n - 1] = '\0';
7398   }
7399
7400   return true;
7401 }
7402
7403 #define TARGET_BIG_SYM          bfd_elf32_sh_vec
7404 #define TARGET_BIG_NAME         "elf32-sh"
7405 #define TARGET_LITTLE_SYM       bfd_elf32_shl_vec
7406 #define TARGET_LITTLE_NAME      "elf32-shl"
7407 #define ELF_ARCH                bfd_arch_sh
7408 #define ELF_MACHINE_CODE        EM_SH
7409 #define ELF_MAXPAGESIZE         128
7410
7411 #define elf_symbol_leading_char '_'
7412
7413 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7414 #define elf_info_to_howto               sh_elf_info_to_howto
7415 #define bfd_elf32_bfd_relax_section     sh_elf_relax_section
7416 #define elf_backend_relocate_section    sh_elf_relocate_section
7417 #define bfd_elf32_bfd_get_relocated_section_contents \
7418                                         sh_elf_get_relocated_section_contents
7419 #define bfd_elf32_mkobject              sh_elf_mkobject
7420 #define elf_backend_object_p            sh_elf_object_p
7421 #define bfd_elf32_bfd_set_private_bfd_flags \
7422                                         sh_elf_set_private_flags
7423 #define bfd_elf32_bfd_copy_private_bfd_data \
7424                                         sh_elf_copy_private_data
7425 #define bfd_elf32_bfd_merge_private_bfd_data \
7426                                         sh_elf_merge_private_data
7427
7428 #define elf_backend_gc_mark_hook        sh_elf_gc_mark_hook
7429 #define elf_backend_gc_sweep_hook       sh_elf_gc_sweep_hook
7430 #define elf_backend_check_relocs        sh_elf_check_relocs
7431 #define elf_backend_copy_indirect_symbol \
7432                                         sh_elf_copy_indirect_symbol
7433 #define elf_backend_create_dynamic_sections \
7434                                         sh_elf_create_dynamic_sections
7435 #define bfd_elf32_bfd_link_hash_table_create \
7436                                         sh_elf_link_hash_table_create
7437 #define elf_backend_adjust_dynamic_symbol \
7438                                         sh_elf_adjust_dynamic_symbol
7439 #define elf_backend_size_dynamic_sections \
7440                                         sh_elf_size_dynamic_sections
7441 #define elf_backend_finish_dynamic_symbol \
7442                                         sh_elf_finish_dynamic_symbol
7443 #define elf_backend_finish_dynamic_sections \
7444                                         sh_elf_finish_dynamic_sections
7445 #define elf_backend_reloc_type_class    sh_elf_reloc_type_class
7446
7447 #define elf_backend_can_gc_sections     1
7448 #define elf_backend_can_refcount        1
7449 #define elf_backend_want_got_plt        1
7450 #define elf_backend_plt_readonly        1
7451 #define elf_backend_want_plt_sym        0
7452 #define elf_backend_got_header_size     12
7453 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
7454
7455 #ifndef INCLUDE_SHMEDIA
7456
7457 #include "elf32-target.h"
7458
7459 /* NetBSD support.  */
7460 #undef  TARGET_BIG_SYM
7461 #define TARGET_BIG_SYM                  bfd_elf32_shnbsd_vec
7462 #undef  TARGET_BIG_NAME
7463 #define TARGET_BIG_NAME                 "elf32-sh-nbsd"
7464 #undef  TARGET_LITTLE_SYM
7465 #define TARGET_LITTLE_SYM               bfd_elf32_shlnbsd_vec
7466 #undef  TARGET_LITTLE_NAME
7467 #define TARGET_LITTLE_NAME              "elf32-shl-nbsd"
7468 #undef  ELF_MAXPAGESIZE
7469 #define ELF_MAXPAGESIZE                 0x10000
7470 #undef  elf_symbol_leading_char
7471 #define elf_symbol_leading_char         0
7472
7473 #define elf32_bed                       elf32_sh_nbsd_bed
7474
7475 #include "elf32-target.h"
7476
7477 #undef  elf32_bed
7478
7479 /* Linux support.  */
7480 #undef  TARGET_BIG_SYM
7481 #define TARGET_BIG_SYM                  bfd_elf32_shblin_vec
7482 #undef  TARGET_BIG_NAME
7483 #define TARGET_BIG_NAME                 "elf32-shbig-linux"
7484 #undef  TARGET_LITTLE_SYM
7485 #define TARGET_LITTLE_SYM               bfd_elf32_shlin_vec
7486 #undef  TARGET_LITTLE_NAME
7487 #define TARGET_LITTLE_NAME              "elf32-sh-linux"
7488
7489 #undef  elf_backend_grok_prstatus
7490 #define elf_backend_grok_prstatus       elf32_shlin_grok_prstatus
7491 #undef  elf_backend_grok_psinfo
7492 #define elf_backend_grok_psinfo         elf32_shlin_grok_psinfo
7493
7494 #define elf32_bed                       elf32_sh_lin_bed
7495
7496 #include "elf32-target.h"
7497
7498 #undef  elf_backend_grok_prstatus
7499 #undef  elf_backend_grok_psinfo
7500 #undef  elf32_bed
7501
7502 #endif /* INCLUDE_SHMEDIA */