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               bfd_byte *loc;
4879               boolean skip, relocate;
4880
4881               /* When generating a shared object, these relocations
4882                  are copied into the output file to be resolved at run
4883                  time.  */
4884
4885               if (sreloc == NULL)
4886                 {
4887                   const char *name;
4888
4889                   name = (bfd_elf_string_from_elf_section
4890                           (input_bfd,
4891                            elf_elfheader (input_bfd)->e_shstrndx,
4892                            elf_section_data (input_section)->rel_hdr.sh_name));
4893                   if (name == NULL)
4894                     return false;
4895
4896                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4897                               && strcmp (bfd_get_section_name (input_bfd,
4898                                                                input_section),
4899                                          name + 5) == 0);
4900
4901                   sreloc = bfd_get_section_by_name (dynobj, name);
4902                   BFD_ASSERT (sreloc != NULL);
4903                 }
4904
4905               skip = false;
4906               relocate = false;
4907
4908               outrel.r_offset =
4909                 _bfd_elf_section_offset (output_bfd, info, input_section,
4910                                          rel->r_offset);
4911               if (outrel.r_offset == (bfd_vma) -1)
4912                 skip = true;
4913               else if (outrel.r_offset == (bfd_vma) -2)
4914                 skip = true, relocate = true;
4915               outrel.r_offset += (input_section->output_section->vma
4916                                   + input_section->output_offset);
4917
4918               if (skip)
4919                 memset (&outrel, 0, sizeof outrel);
4920               else if (r_type == R_SH_REL32)
4921                 {
4922                   BFD_ASSERT (h != NULL && h->dynindx != -1);
4923                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
4924                   outrel.r_addend
4925                     = bfd_get_32 (input_bfd, contents + rel->r_offset);
4926                 }
4927               else
4928                 {
4929                   /* h->dynindx may be -1 if this symbol was marked to
4930                      become local.  */
4931                   if (h == NULL
4932                       || ((info->symbolic || h->dynindx == -1)
4933                           && (h->elf_link_hash_flags
4934                               & ELF_LINK_HASH_DEF_REGULAR) != 0))
4935                     {
4936                       relocate = true;
4937                       outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4938                       outrel.r_addend
4939                         = relocation + bfd_get_32 (input_bfd,
4940                                                    contents + rel->r_offset);
4941                     }
4942                   else
4943                     {
4944                       BFD_ASSERT (h->dynindx != -1);
4945                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
4946                       outrel.r_addend
4947                         = relocation + bfd_get_32 (input_bfd,
4948                                                    contents + rel->r_offset);
4949                     }
4950                 }
4951
4952               loc = sreloc->contents;
4953               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4954               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4955
4956               /* If this reloc is against an external symbol, we do
4957                  not want to fiddle with the addend.  Otherwise, we
4958                  need to include the symbol value so that it becomes
4959                  an addend for the dynamic reloc.  */
4960               if (! relocate)
4961                 continue;
4962             }
4963           goto final_link_relocate;
4964
4965         case R_SH_GOTPLT32:
4966 #ifdef INCLUDE_SHMEDIA
4967         case R_SH_GOTPLT_LOW16:
4968         case R_SH_GOTPLT_MEDLOW16:
4969         case R_SH_GOTPLT_MEDHI16:
4970         case R_SH_GOTPLT_HI16:
4971         case R_SH_GOTPLT10BY4:
4972         case R_SH_GOTPLT10BY8:
4973 #endif
4974           /* Relocation is to the entry for this symbol in the
4975              procedure linkage table.  */
4976
4977           if (h == NULL
4978               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
4979               || ! info->shared
4980               || info->symbolic
4981               || h->dynindx == -1
4982               || h->plt.offset == (bfd_vma) -1
4983               || h->got.offset != (bfd_vma) -1)
4984             goto force_got;
4985
4986           /* Relocation is to the entry for this symbol in the global
4987              offset table extension for the procedure linkage table.  */
4988
4989           BFD_ASSERT (sgotplt != NULL);
4990           relocation = (sgotplt->output_offset
4991                         + ((h->plt.offset / elf_sh_sizeof_plt (info)
4992                             - 1 + 3) * 4));
4993
4994 #ifdef GOT_BIAS
4995           relocation -= GOT_BIAS;
4996 #endif
4997
4998           goto final_link_relocate;
4999
5000         force_got:
5001         case R_SH_GOT32:
5002 #ifdef INCLUDE_SHMEDIA
5003         case R_SH_GOT_LOW16:
5004         case R_SH_GOT_MEDLOW16:
5005         case R_SH_GOT_MEDHI16:
5006         case R_SH_GOT_HI16:
5007         case R_SH_GOT10BY4:
5008         case R_SH_GOT10BY8:
5009 #endif
5010           /* Relocation is to the entry for this symbol in the global
5011              offset table.  */
5012
5013           BFD_ASSERT (sgot != NULL);
5014
5015           if (h != NULL)
5016             {
5017               boolean dyn;
5018
5019               off = h->got.offset;
5020 #ifdef INCLUDE_SHMEDIA
5021               if (seen_stt_datalabel)
5022                 {
5023                   struct elf_sh_link_hash_entry *hsh;
5024
5025                   hsh = (struct elf_sh_link_hash_entry *)h;
5026                   off = hsh->datalabel_got.offset;
5027                 }
5028 #endif
5029               BFD_ASSERT (off != (bfd_vma) -1);
5030
5031               dyn = htab->root.dynamic_sections_created;
5032               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
5033                   || (info->shared
5034                       && (info->symbolic || h->dynindx == -1
5035                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
5036                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5037                 {
5038                   /* This is actually a static link, or it is a
5039                      -Bsymbolic link and the symbol is defined
5040                      locally, or the symbol was forced to be local
5041                      because of a version file.  We must initialize
5042                      this entry in the global offset table.  Since the
5043                      offset must always be a multiple of 4, we use the
5044                      least significant bit to record whether we have
5045                      initialized it already.
5046
5047                      When doing a dynamic link, we create a .rela.got
5048                      relocation entry to initialize the value.  This
5049                      is done in the finish_dynamic_symbol routine.  */
5050                   if ((off & 1) != 0)
5051                     off &= ~1;
5052                   else
5053                     {
5054                       bfd_put_32 (output_bfd, relocation,
5055                                   sgot->contents + off);
5056 #ifdef INCLUDE_SHMEDIA
5057                       if (seen_stt_datalabel)
5058                         {
5059                           struct elf_sh_link_hash_entry *hsh;
5060
5061                           hsh = (struct elf_sh_link_hash_entry *)h;
5062                           hsh->datalabel_got.offset |= 1;
5063                         }
5064                       else
5065 #endif
5066                         h->got.offset |= 1;
5067                     }
5068                 }
5069
5070               relocation = sgot->output_offset + off;
5071             }
5072           else
5073             {
5074 #ifdef INCLUDE_SHMEDIA
5075               if (rel->r_addend)
5076                 {
5077                   BFD_ASSERT (local_got_offsets != NULL
5078                               && (local_got_offsets[symtab_hdr->sh_info
5079                                                     + r_symndx]
5080                                   != (bfd_vma) -1));
5081
5082                   off = local_got_offsets[symtab_hdr->sh_info
5083                                           + r_symndx];
5084                 }
5085               else
5086                 {
5087 #endif
5088               BFD_ASSERT (local_got_offsets != NULL
5089                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
5090
5091               off = local_got_offsets[r_symndx];
5092 #ifdef INCLUDE_SHMEDIA
5093                 }
5094 #endif
5095
5096               /* The offset must always be a multiple of 4.  We use
5097                  the least significant bit to record whether we have
5098                  already generated the necessary reloc.  */
5099               if ((off & 1) != 0)
5100                 off &= ~1;
5101               else
5102                 {
5103                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5104
5105                   if (info->shared)
5106                     {
5107                       Elf_Internal_Rela outrel;
5108                       bfd_byte *loc;
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                       loc = srelgot->contents;
5123                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5124                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5125                     }
5126
5127 #ifdef INCLUDE_SHMEDIA
5128                   if (rel->r_addend)
5129                     local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
5130                   else
5131 #endif
5132                     local_got_offsets[r_symndx] |= 1;
5133                 }
5134
5135               relocation = sgot->output_offset + off;
5136             }
5137
5138 #ifdef GOT_BIAS
5139           relocation -= GOT_BIAS;
5140 #endif
5141
5142           goto final_link_relocate;
5143
5144         case R_SH_GOTOFF:
5145 #ifdef INCLUDE_SHMEDIA
5146         case R_SH_GOTOFF_LOW16:
5147         case R_SH_GOTOFF_MEDLOW16:
5148         case R_SH_GOTOFF_MEDHI16:
5149         case R_SH_GOTOFF_HI16:
5150 #endif
5151           /* Relocation is relative to the start of the global offset
5152              table.  */
5153
5154           BFD_ASSERT (sgot != NULL);
5155
5156           /* Note that sgot->output_offset is not involved in this
5157              calculation.  We always want the start of .got.  If we
5158              defined _GLOBAL_OFFSET_TABLE in a different way, as is
5159              permitted by the ABI, we might have to change this
5160              calculation.  */
5161           relocation -= sgot->output_section->vma;
5162
5163 #ifdef GOT_BIAS
5164           relocation -= GOT_BIAS;
5165 #endif
5166
5167           addend = rel->r_addend;
5168
5169           goto final_link_relocate;
5170
5171         case R_SH_GOTPC:
5172 #ifdef INCLUDE_SHMEDIA
5173         case R_SH_GOTPC_LOW16:
5174         case R_SH_GOTPC_MEDLOW16:
5175         case R_SH_GOTPC_MEDHI16:
5176         case R_SH_GOTPC_HI16:
5177 #endif
5178           /* Use global offset table as symbol value.  */
5179
5180           BFD_ASSERT (sgot != NULL);
5181           relocation = sgot->output_section->vma;
5182
5183 #ifdef GOT_BIAS
5184           relocation += GOT_BIAS;
5185 #endif
5186
5187           addend = rel->r_addend;
5188
5189           goto final_link_relocate;
5190
5191         case R_SH_PLT32:
5192 #ifdef INCLUDE_SHMEDIA
5193         case R_SH_PLT_LOW16:
5194         case R_SH_PLT_MEDLOW16:
5195         case R_SH_PLT_MEDHI16:
5196         case R_SH_PLT_HI16:
5197 #endif
5198           /* Relocation is to the entry for this symbol in the
5199              procedure linkage table.  */
5200
5201           /* Resolve a PLT reloc against a local symbol directly,
5202              without using the procedure linkage table.  */
5203           if (h == NULL)
5204             goto final_link_relocate;
5205
5206           if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
5207             goto final_link_relocate;
5208
5209           if (h->plt.offset == (bfd_vma) -1)
5210             {
5211               /* We didn't make a PLT entry for this symbol.  This
5212                  happens when statically linking PIC code, or when
5213                  using -Bsymbolic.  */
5214               goto final_link_relocate;
5215             }
5216
5217           BFD_ASSERT (splt != NULL);
5218           relocation = (splt->output_section->vma
5219                         + splt->output_offset
5220                         + h->plt.offset);
5221
5222 #ifdef INCLUDE_SHMEDIA
5223           relocation++;
5224 #endif
5225
5226           addend = rel->r_addend;
5227
5228           goto final_link_relocate;
5229
5230         case R_SH_LOOP_START:
5231           {
5232             static bfd_vma start, end;
5233
5234             start = (relocation + rel->r_addend
5235                      - (sec->output_section->vma + sec->output_offset));
5236             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5237                                    rel->r_offset, sec, start, end);
5238             break;
5239
5240         case R_SH_LOOP_END:
5241             end = (relocation + rel->r_addend
5242                    - (sec->output_section->vma + sec->output_offset));
5243             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5244                                    rel->r_offset, sec, start, end);
5245             break;
5246           }
5247
5248         case R_SH_TLS_GD_32:
5249         case R_SH_TLS_IE_32:
5250           r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5251           tls_type = GOT_UNKNOWN;
5252           if (h == NULL && local_got_offsets)
5253             tls_type = sh_elf_local_got_tls_type (input_bfd) [r_symndx];
5254           else if (h != NULL)
5255             {
5256               tls_type = sh_elf_hash_entry (h)->tls_type;
5257               if (! info->shared
5258                   && (h->dynindx == -1
5259                       || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
5260                   && (tls_type == GOT_TLS_IE
5261                       || sh_elf_hash_entry (h)->tls_tpoff32))
5262                 r_type = R_SH_TLS_LE_32;
5263             }
5264
5265           if (r_type == R_SH_TLS_GD_32 && tls_type == GOT_TLS_IE)
5266             r_type = R_SH_TLS_IE_32;
5267
5268           if (r_type == R_SH_TLS_LE_32)
5269             {
5270               bfd_vma offset;
5271               unsigned short insn;
5272               int indx;
5273               Elf_Internal_Rela outrel;
5274               bfd_byte *loc;
5275
5276               if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
5277                 {
5278                   /* GD->LE transition:
5279                        mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5280                        jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5281                        1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5282                      We change it into:
5283                        mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5284                        nop; nop; ...
5285                        1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:.  */
5286
5287                   offset = rel->r_offset;
5288                   BFD_ASSERT (offset >= 16);
5289                   /* Size of GD instructions is 16 or 18.  */
5290                   offset -= 16;
5291                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5292                   if ((insn & 0xff00) == 0xc700)
5293                     {
5294                       BFD_ASSERT (offset >= 2);
5295                       offset -= 2;
5296                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
5297                     }
5298
5299                   BFD_ASSERT ((insn & 0xff00) == 0xd400);
5300                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
5301                   BFD_ASSERT ((insn & 0xff00) == 0xc700);
5302                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
5303                   BFD_ASSERT ((insn & 0xff00) == 0xd100);
5304                   insn = bfd_get_16 (input_bfd, contents + offset + 6);
5305                   BFD_ASSERT (insn == 0x310c);
5306                   insn = bfd_get_16 (input_bfd, contents + offset + 8);
5307                   BFD_ASSERT (insn == 0x410b);
5308                   insn = bfd_get_16 (input_bfd, contents + offset + 10);
5309                   BFD_ASSERT (insn == 0x34cc);
5310
5311                   bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
5312                   bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
5313                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5314                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5315                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5316                 }
5317               else
5318                 {
5319                   int index;
5320
5321                   /* IE->LE transition:
5322                      mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5323                      bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5324                      We change it into:
5325                      mov.l .Ln,rM; stc gbr,rN; nop; ...;
5326                      1: x@TPOFF; 2:.  */
5327
5328                   offset = rel->r_offset;
5329                   BFD_ASSERT (offset >= 16);
5330                   /* Size of IE instructions is 10 or 12.  */
5331                   offset -= 10;
5332                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5333                   if ((insn & 0xf0ff) == 0x0012)
5334                     {
5335                       BFD_ASSERT (offset >= 2);
5336                       offset -= 2;
5337                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
5338                     }
5339
5340                   BFD_ASSERT ((insn & 0xff00) == 0xd000);
5341                   index = insn & 0x00ff;
5342                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
5343                   BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
5344                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
5345                   BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
5346                   insn = 0xd000 | (insn & 0x0f00) | index;
5347                   bfd_put_16 (output_bfd, insn, contents + offset + 0);
5348                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5349                 }
5350
5351               if (sreloc == NULL)
5352                 {
5353                   const char *name;
5354
5355                   name = (bfd_elf_string_from_elf_section
5356                           (input_bfd,
5357                            elf_elfheader (input_bfd)->e_shstrndx,
5358                            elf_section_data (input_section)->rel_hdr.sh_name));
5359                   if (name == NULL)
5360                     return false;
5361
5362                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5363                               && strcmp (bfd_get_section_name (input_bfd,
5364                                                                input_section),
5365                                          name + 5) == 0);
5366
5367                   sreloc = bfd_get_section_by_name (dynobj, name);
5368                   BFD_ASSERT (sreloc != NULL);
5369                 }
5370
5371               indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5372               outrel.r_offset = (input_section->output_section->vma
5373                                  + input_section->output_offset
5374                                  + rel->r_offset);
5375               outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5376               if (indx == 0)
5377                 outrel.r_addend = relocation - dtpoff_base (info);
5378               else
5379                 outrel.r_addend = 0;
5380
5381               loc = sreloc->contents;
5382               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5383               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5384               continue;
5385             }
5386
5387           sgot = htab->sgot;
5388           if (sgot == NULL)
5389             abort ();
5390
5391           if (h != NULL)
5392             off = h->got.offset;
5393           else
5394             {
5395               if (local_got_offsets == NULL)
5396                 abort ();
5397
5398               off = local_got_offsets[r_symndx];
5399             }
5400
5401           if ((off & 1) != 0)
5402             off &= ~1;
5403           else
5404             {
5405               Elf_Internal_Rela outrel;
5406               bfd_byte *loc;
5407               int dr_type, indx;
5408
5409               if (srelgot == NULL)
5410                 {
5411                   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5412                   BFD_ASSERT (srelgot != NULL);
5413                 }
5414
5415               outrel.r_offset = (sgot->output_section->vma
5416                                  + sgot->output_offset + off);
5417
5418               indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5419               dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
5420                          R_SH_TLS_TPOFF32);
5421               if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
5422                 outrel.r_addend = relocation - dtpoff_base (info);
5423               else
5424                 outrel.r_addend = 0;
5425               outrel.r_info = ELF32_R_INFO (indx, dr_type);
5426               loc = srelgot->contents;
5427               loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5428               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5429
5430               if (r_type == R_SH_TLS_GD_32)
5431                 {
5432                   if (indx == 0)
5433                     {
5434                       bfd_put_32 (output_bfd,
5435                                   relocation - dtpoff_base (info),
5436                                   sgot->contents + off + 4);
5437                     }
5438                   else
5439                     {
5440                       outrel.r_info = ELF32_R_INFO (indx,
5441                                                     R_SH_TLS_DTPOFF32);
5442                       outrel.r_offset += 4;
5443                       outrel.r_addend = 0;
5444                       srelgot->reloc_count++;
5445                       loc += sizeof (Elf32_External_Rela);
5446                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5447                     }
5448                 }
5449
5450               if (h != NULL)
5451                 h->got.offset |= 1;
5452               else
5453                 local_got_offsets[r_symndx] |= 1;
5454             }
5455
5456           if (off >= (bfd_vma) -2)
5457             abort ();
5458
5459           if (r_type == (int) ELF32_R_TYPE (rel->r_info))
5460             relocation = sgot->output_offset + off;
5461           else
5462             {
5463               bfd_vma offset;
5464               unsigned short insn;
5465
5466               /* GD->IE transition:
5467                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5468                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5469                    1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5470                  We change it into:
5471                    mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5472                    nop; nop; bra 3f; nop; .align 2;
5473                    1: .long x@TPOFF; 2:...; 3:.  */
5474
5475               offset = rel->r_offset;
5476               BFD_ASSERT (offset >= 16);
5477               /* Size of GD instructions is 16 or 18.  */
5478               offset -= 16;
5479               insn = bfd_get_16 (input_bfd, contents + offset + 0);
5480               if ((insn & 0xff00) == 0xc700)
5481                 {
5482                   BFD_ASSERT (offset >= 2);
5483                   offset -= 2;
5484                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5485                 }
5486
5487               BFD_ASSERT ((insn & 0xff00) == 0xd400);
5488
5489               /* Replace mov.l 1f,R4 with mov.l 1f,r0.  */
5490               bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
5491
5492               insn = bfd_get_16 (input_bfd, contents + offset + 2);
5493               BFD_ASSERT ((insn & 0xff00) == 0xc700);
5494               insn = bfd_get_16 (input_bfd, contents + offset + 4);
5495               BFD_ASSERT ((insn & 0xff00) == 0xd100);
5496               insn = bfd_get_16 (input_bfd, contents + offset + 6);
5497               BFD_ASSERT (insn == 0x310c);
5498               insn = bfd_get_16 (input_bfd, contents + offset + 8);
5499               BFD_ASSERT (insn == 0x410b);
5500               insn = bfd_get_16 (input_bfd, contents + offset + 10);
5501               BFD_ASSERT (insn == 0x34cc);
5502
5503               bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
5504               bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
5505               bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
5506               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5507               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5508
5509               bfd_put_32 (output_bfd, sgot->output_offset + off,
5510                           contents + rel->r_offset);
5511
5512               continue;
5513           }
5514
5515           addend = rel->r_addend;
5516
5517           goto final_link_relocate;
5518
5519         case R_SH_TLS_LD_32:
5520           if (! info->shared)
5521             {
5522               bfd_vma offset;
5523               unsigned short insn;
5524
5525               /* LD->LE transition:
5526                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5527                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5528                    1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5529                  We change it into:
5530                    stc gbr,r0; nop; nop; nop;
5531                    nop; nop; bra 3f; ...; 3:.  */
5532
5533               offset = rel->r_offset;
5534               BFD_ASSERT (offset >= 16);
5535               /* Size of LD instructions is 16 or 18.  */
5536               offset -= 16;
5537               insn = bfd_get_16 (input_bfd, contents + offset + 0);
5538               if ((insn & 0xff00) == 0xc700)
5539                 {
5540                   BFD_ASSERT (offset >= 2);
5541                   offset -= 2;
5542                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5543                 }
5544
5545               BFD_ASSERT ((insn & 0xff00) == 0xd400);
5546               insn = bfd_get_16 (input_bfd, contents + offset + 2);
5547               BFD_ASSERT ((insn & 0xff00) == 0xc700);
5548               insn = bfd_get_16 (input_bfd, contents + offset + 4);
5549               BFD_ASSERT ((insn & 0xff00) == 0xd100);
5550               insn = bfd_get_16 (input_bfd, contents + offset + 6);
5551               BFD_ASSERT (insn == 0x310c);
5552               insn = bfd_get_16 (input_bfd, contents + offset + 8);
5553               BFD_ASSERT (insn == 0x410b);
5554               insn = bfd_get_16 (input_bfd, contents + offset + 10);
5555               BFD_ASSERT (insn == 0x34cc);
5556
5557               bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5558               bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5559               bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5560               bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5561               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5562               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5563
5564               continue;
5565             }
5566
5567           sgot = htab->sgot;
5568           if (sgot == NULL)
5569             abort ();
5570
5571           off = htab->tls_ldm_got.offset;
5572           if (off & 1)
5573             off &= ~1;
5574           else
5575             {
5576               Elf_Internal_Rela outrel;
5577               bfd_byte *loc;
5578
5579               srelgot = htab->srelgot;
5580               if (srelgot == NULL)
5581                 abort ();
5582
5583               outrel.r_offset = (sgot->output_section->vma
5584                                  + sgot->output_offset + off);
5585               outrel.r_addend = 0;
5586               outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
5587               loc = srelgot->contents;
5588               loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5589               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5590               htab->tls_ldm_got.offset |= 1;
5591             }
5592
5593           relocation = sgot->output_offset + off;
5594           addend = rel->r_addend;
5595
5596           goto final_link_relocate;
5597
5598         case R_SH_TLS_LDO_32:
5599           if (! info->shared)
5600             {
5601               int indx;
5602               Elf_Internal_Rela outrel;
5603               bfd_byte *loc;
5604
5605               if (sreloc == NULL)
5606                 {
5607                   const char *name;
5608
5609                   name = (bfd_elf_string_from_elf_section
5610                           (input_bfd,
5611                            elf_elfheader (input_bfd)->e_shstrndx,
5612                            elf_section_data (input_section)->rel_hdr.sh_name));
5613                   if (name == NULL)
5614                     return false;
5615
5616                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5617                               && strcmp (bfd_get_section_name (input_bfd,
5618                                                                input_section),
5619                                          name + 5) == 0);
5620
5621                   sreloc = bfd_get_section_by_name (dynobj, name);
5622                   BFD_ASSERT (sreloc != NULL);
5623                 }
5624
5625               indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5626               outrel.r_offset = (input_section->output_section->vma
5627                                  + input_section->output_offset
5628                                  + rel->r_offset);
5629               outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5630               if (indx == 0)
5631                 outrel.r_addend = relocation - dtpoff_base (info);
5632               else
5633                 outrel.r_addend = 0;
5634
5635               loc = sreloc->contents;
5636               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5637               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5638               continue;
5639             }
5640           else
5641             relocation -= dtpoff_base (info);
5642
5643           addend = rel->r_addend;
5644           goto final_link_relocate;
5645
5646         case R_SH_TLS_LE_32:
5647           {
5648             int indx;
5649             Elf_Internal_Rela outrel;
5650             bfd_byte *loc;
5651
5652             if (sreloc == NULL)
5653               {
5654                 const char *name;
5655
5656                 name = (bfd_elf_string_from_elf_section
5657                         (input_bfd,
5658                          elf_elfheader (input_bfd)->e_shstrndx,
5659                          elf_section_data (input_section)->rel_hdr.sh_name));
5660                 if (name == NULL)
5661                   return false;
5662
5663                 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5664                             && strcmp (bfd_get_section_name (input_bfd,
5665                                                              input_section),
5666                                        name + 5) == 0);
5667
5668                 sreloc = bfd_get_section_by_name (dynobj, name);
5669                 BFD_ASSERT (sreloc != NULL);
5670               }
5671
5672             indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5673             outrel.r_offset = (input_section->output_section->vma
5674                                + input_section->output_offset
5675                                + rel->r_offset);
5676             outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5677             if (indx == 0)
5678               outrel.r_addend = relocation - dtpoff_base (info);
5679             else
5680               outrel.r_addend = 0;
5681
5682             loc = sreloc->contents;
5683             loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5684             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5685             continue;
5686           }
5687         }
5688
5689     relocation_done:
5690       if (r != bfd_reloc_ok)
5691         {
5692           switch (r)
5693             {
5694             default:
5695             case bfd_reloc_outofrange:
5696               abort ();
5697             case bfd_reloc_overflow:
5698               {
5699                 const char *name;
5700
5701                 if (h != NULL)
5702                   name = h->root.root.string;
5703                 else
5704                   {
5705                     name = (bfd_elf_string_from_elf_section
5706                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
5707                     if (name == NULL)
5708                       return false;
5709                     if (*name == '\0')
5710                       name = bfd_section_name (input_bfd, sec);
5711                   }
5712                 if (! ((*info->callbacks->reloc_overflow)
5713                        (info, name, howto->name, (bfd_vma) 0,
5714                         input_bfd, input_section, rel->r_offset)))
5715                   return false;
5716               }
5717               break;
5718             }
5719         }
5720     }
5721
5722   return true;
5723 }
5724
5725 /* This is a version of bfd_generic_get_relocated_section_contents
5726    which uses sh_elf_relocate_section.  */
5727
5728 static bfd_byte *
5729 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
5730                                        data, relocateable, symbols)
5731      bfd *output_bfd;
5732      struct bfd_link_info *link_info;
5733      struct bfd_link_order *link_order;
5734      bfd_byte *data;
5735      boolean relocateable;
5736      asymbol **symbols;
5737 {
5738   Elf_Internal_Shdr *symtab_hdr;
5739   asection *input_section = link_order->u.indirect.section;
5740   bfd *input_bfd = input_section->owner;
5741   asection **sections = NULL;
5742   Elf_Internal_Rela *internal_relocs = NULL;
5743   Elf_Internal_Sym *isymbuf = NULL;
5744
5745   /* We only need to handle the case of relaxing, or of having a
5746      particular set of section contents, specially.  */
5747   if (relocateable
5748       || elf_section_data (input_section)->this_hdr.contents == NULL)
5749     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5750                                                        link_order, data,
5751                                                        relocateable,
5752                                                        symbols);
5753
5754   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5755
5756   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5757           (size_t) input_section->_raw_size);
5758
5759   if ((input_section->flags & SEC_RELOC) != 0
5760       && input_section->reloc_count > 0)
5761     {
5762       asection **secpp;
5763       Elf_Internal_Sym *isym, *isymend;
5764       bfd_size_type amt;
5765
5766       internal_relocs = (_bfd_elf32_link_read_relocs
5767                          (input_bfd, input_section, (PTR) NULL,
5768                           (Elf_Internal_Rela *) NULL, false));
5769       if (internal_relocs == NULL)
5770         goto error_return;
5771
5772       if (symtab_hdr->sh_info != 0)
5773         {
5774           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5775           if (isymbuf == NULL)
5776             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5777                                             symtab_hdr->sh_info, 0,
5778                                             NULL, NULL, NULL);
5779           if (isymbuf == NULL)
5780             goto error_return;
5781         }
5782
5783       amt = symtab_hdr->sh_info;
5784       amt *= sizeof (asection *);
5785       sections = (asection **) bfd_malloc (amt);
5786       if (sections == NULL && amt != 0)
5787         goto error_return;
5788
5789       isymend = isymbuf + symtab_hdr->sh_info;
5790       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5791         {
5792           asection *isec;
5793
5794           if (isym->st_shndx == SHN_UNDEF)
5795             isec = bfd_und_section_ptr;
5796           else if (isym->st_shndx == SHN_ABS)
5797             isec = bfd_abs_section_ptr;
5798           else if (isym->st_shndx == SHN_COMMON)
5799             isec = bfd_com_section_ptr;
5800           else
5801             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5802
5803           *secpp = isec;
5804         }
5805
5806       if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5807                                      input_section, data, internal_relocs,
5808                                      isymbuf, sections))
5809         goto error_return;
5810
5811       if (sections != NULL)
5812         free (sections);
5813       if (isymbuf != NULL
5814           && symtab_hdr->contents != (unsigned char *) isymbuf)
5815         free (isymbuf);
5816       if (elf_section_data (input_section)->relocs != internal_relocs)
5817         free (internal_relocs);
5818     }
5819
5820   return data;
5821
5822  error_return:
5823   if (sections != NULL)
5824     free (sections);
5825   if (isymbuf != NULL
5826       && symtab_hdr->contents != (unsigned char *) isymbuf)
5827     free (isymbuf);
5828   if (internal_relocs != NULL
5829       && elf_section_data (input_section)->relocs != internal_relocs)
5830     free (internal_relocs);
5831   return NULL;
5832 }
5833
5834 /* Return the base VMA address which should be subtracted from real addresses
5835    when resolving @dtpoff relocation.
5836    This is PT_TLS segment p_vaddr.  */
5837
5838 static bfd_vma
5839 dtpoff_base (info)
5840      struct bfd_link_info *info;
5841 {
5842  /* If tls_segment is NULL, we should have signalled an error already.  */
5843  if (elf_hash_table (info)->tls_segment == NULL)
5844    return 0;
5845   return elf_hash_table (info)->tls_segment->start;
5846 }
5847
5848 static asection *
5849 sh_elf_gc_mark_hook (sec, info, rel, h, sym)
5850      asection *sec;
5851      struct bfd_link_info *info ATTRIBUTE_UNUSED;
5852      Elf_Internal_Rela *rel;
5853      struct elf_link_hash_entry *h;
5854      Elf_Internal_Sym *sym;
5855 {
5856   if (h != NULL)
5857     {
5858       switch (ELF32_R_TYPE (rel->r_info))
5859         {
5860         case R_SH_GNU_VTINHERIT:
5861         case R_SH_GNU_VTENTRY:
5862           break;
5863
5864         default:
5865 #ifdef INCLUDE_SHMEDIA
5866           while (h->root.type == bfd_link_hash_indirect
5867                  && h->root.u.i.link)
5868             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5869 #endif
5870           switch (h->root.type)
5871             {
5872             case bfd_link_hash_defined:
5873             case bfd_link_hash_defweak:
5874               return h->root.u.def.section;
5875
5876             case bfd_link_hash_common:
5877               return h->root.u.c.p->section;
5878
5879             default:
5880               break;
5881             }
5882         }
5883     }
5884   else
5885     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5886
5887   return NULL;
5888 }
5889
5890 /* Update the got entry reference counts for the section being removed.  */
5891
5892 static boolean
5893 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
5894      bfd *abfd;
5895      struct bfd_link_info *info;
5896      asection *sec;
5897      const Elf_Internal_Rela *relocs;
5898 {
5899   Elf_Internal_Shdr *symtab_hdr;
5900   struct elf_link_hash_entry **sym_hashes;
5901   bfd_signed_vma *local_got_refcounts;
5902   const Elf_Internal_Rela *rel, *relend;
5903   unsigned long r_symndx;
5904   struct elf_link_hash_entry *h;
5905   struct elf_sh_link_hash_entry *eh;
5906
5907   elf_section_data (sec)->local_dynrel = NULL;
5908
5909   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5910   sym_hashes = elf_sym_hashes (abfd);
5911   local_got_refcounts = elf_local_got_refcounts (abfd);
5912
5913   relend = relocs + sec->reloc_count;
5914   for (rel = relocs; rel < relend; rel++)
5915     {
5916 #ifdef INCLUDE_SHMEDIA
5917       int seen_stt_datalabel = 0;
5918 #endif
5919
5920       r_symndx = ELF32_R_SYM (rel->r_info);
5921       if (r_symndx < symtab_hdr->sh_info)
5922         h = NULL;
5923       else
5924         {
5925           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5926 #ifdef INCLUDE_SHMEDIA
5927           while (h->root.type == bfd_link_hash_indirect
5928                  || h->root.type == bfd_link_hash_warning)
5929             {
5930               seen_stt_datalabel |= h->type == STT_DATALABEL;
5931               h = (struct elf_link_hash_entry *) h->root.u.i.link;
5932             }
5933 #endif
5934         }
5935       eh = (struct elf_sh_link_hash_entry *) h;
5936
5937       switch (sh_elf_optimized_tls_reloc (info, ELF32_R_TYPE (rel->r_info),
5938                                           ELF32_R_SYM (rel->r_info)
5939                                           >= symtab_hdr->sh_info))
5940         {
5941         case R_SH_TLS_LD_32:
5942           if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0)
5943             sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
5944           break;
5945
5946         case R_SH_GOT32:
5947         case R_SH_GOTOFF:
5948         case R_SH_GOTPC:
5949 #ifdef INCLUDE_SHMEDIA
5950         case R_SH_GOT_LOW16:
5951         case R_SH_GOT_MEDLOW16:
5952         case R_SH_GOT_MEDHI16:
5953         case R_SH_GOT_HI16:
5954         case R_SH_GOT10BY4:
5955         case R_SH_GOT10BY8:
5956         case R_SH_GOTOFF_LOW16:
5957         case R_SH_GOTOFF_MEDLOW16:
5958         case R_SH_GOTOFF_MEDHI16:
5959         case R_SH_GOTOFF_HI16:
5960         case R_SH_GOTPC_LOW16:
5961         case R_SH_GOTPC_MEDLOW16:
5962         case R_SH_GOTPC_MEDHI16:
5963         case R_SH_GOTPC_HI16:
5964 #endif
5965         case R_SH_TLS_GD_32:
5966         case R_SH_TLS_IE_32:
5967           if (h != NULL)
5968             {
5969 #ifdef INCLUDE_SHMEDIA
5970               if (seen_stt_datalabel)
5971                 {
5972                   if (eh->datalabel_got.refcount > 0)
5973                     eh->datalabel_got.refcount -= 1;
5974                 }
5975               else
5976 #endif
5977                 if (h->got.refcount > 0)
5978                   h->got.refcount -= 1;
5979             }
5980           else if (local_got_refcounts != NULL)
5981             {
5982 #ifdef INCLUDE_SHMEDIA
5983               if (rel->r_addend & 1)
5984                 {
5985                   if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
5986                     local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
5987                 }
5988               else
5989 #endif
5990                 if (local_got_refcounts[r_symndx] > 0)
5991                   local_got_refcounts[r_symndx] -= 1;
5992             }
5993           break;
5994
5995         case R_SH_DIR32:
5996         case R_SH_REL32:
5997           if (h != NULL)
5998             {
5999               struct elf_sh_dyn_relocs **pp;
6000               struct elf_sh_dyn_relocs *p;
6001
6002
6003               if (!info->shared && h->plt.refcount > 0)
6004                 h->plt.refcount -= 1;
6005
6006               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6007                 if (p->sec == sec)
6008                   {
6009                     if (ELF32_R_TYPE (rel->r_info) == R_SH_REL32)
6010                       p->pc_count -= 1;
6011                     p->count -= 1;
6012                     if (p->count == 0)
6013                       *pp = p->next;
6014                     break;
6015                   }
6016             }
6017           break;
6018
6019         case R_SH_PLT32:
6020 #ifdef INCLUDE_SHMEDIA
6021         case R_SH_PLT_LOW16:
6022         case R_SH_PLT_MEDLOW16:
6023         case R_SH_PLT_MEDHI16:
6024         case R_SH_PLT_HI16:
6025 #endif
6026           if (h != NULL)
6027             {
6028               if (h->plt.refcount > 0)
6029                 h->plt.refcount -= 1;
6030             }
6031           break;
6032
6033         case R_SH_GOTPLT32:
6034 #ifdef INCLUDE_SHMEDIA
6035         case R_SH_GOTPLT_LOW16:
6036         case R_SH_GOTPLT_MEDLOW16:
6037         case R_SH_GOTPLT_MEDHI16:
6038         case R_SH_GOTPLT_HI16:
6039         case R_SH_GOTPLT10BY4:
6040         case R_SH_GOTPLT10BY8:
6041 #endif
6042           if (h != NULL)
6043             {
6044               if (eh->gotplt_refcount > 0)
6045                 {
6046                   eh->gotplt_refcount -= 1;
6047                   if (h->plt.refcount > 0)
6048                     h->plt.refcount -= 1;
6049                 }
6050 #ifdef INCLUDE_SHMEDIA
6051               else if (seen_stt_datalabel)
6052                 {
6053                   if (eh->datalabel_got.refcount > 0)
6054                     eh->datalabel_got.refcount -= 1;
6055                 }
6056 #endif
6057               else if (h->got.refcount > 0)
6058                 h->got.refcount -= 1;
6059             }
6060           else if (local_got_refcounts != NULL)
6061             {
6062 #ifdef INCLUDE_SHMEDIA
6063               if (rel->r_addend & 1)
6064                 {
6065                   if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
6066                     local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
6067                 }
6068               else
6069 #endif
6070                 if (local_got_refcounts[r_symndx] > 0)
6071                   local_got_refcounts[r_symndx] -= 1;
6072             }
6073           break;
6074
6075         default:
6076           break;
6077         }
6078     }
6079
6080   return true;
6081 }
6082
6083 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
6084
6085 static void
6086 sh_elf_copy_indirect_symbol (bed, dir, ind)
6087      struct elf_backend_data *bed;
6088      struct elf_link_hash_entry *dir, *ind;
6089 {
6090   struct elf_sh_link_hash_entry *edir, *eind;
6091 #ifdef INCLUDE_SHMEDIA
6092   bfd_signed_vma tmp;
6093 #endif
6094
6095   edir = (struct elf_sh_link_hash_entry *) dir;
6096   eind = (struct elf_sh_link_hash_entry *) ind;
6097
6098   if (eind->dyn_relocs != NULL)
6099     {
6100       if (edir->dyn_relocs != NULL)
6101         {
6102           struct elf_sh_dyn_relocs **pp;
6103           struct elf_sh_dyn_relocs *p;
6104
6105           BFD_ASSERT (ind->root.type != bfd_link_hash_indirect);
6106
6107           /* Add reloc counts against the weak sym to the strong sym
6108              list.  Merge any entries against the same section.  */
6109           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
6110             {
6111               struct elf_sh_dyn_relocs *q;
6112
6113               for (q = edir->dyn_relocs; q != NULL; q = q->next)
6114                 if (q->sec == p->sec)
6115                   {
6116                     q->pc_count += p->pc_count;
6117                     q->count += p->count;
6118                     *pp = p->next;
6119                     break;
6120                   }
6121               if (q == NULL)
6122                 pp = &p->next;
6123             }
6124           *pp = edir->dyn_relocs;
6125         }
6126
6127       edir->dyn_relocs = eind->dyn_relocs;
6128       eind->dyn_relocs = NULL;
6129     }
6130   edir->gotplt_refcount = eind->gotplt_refcount;
6131   eind->gotplt_refcount = 0;
6132 #ifdef INCLUDE_SHMEDIA
6133   tmp = edir->datalabel_got.refcount;
6134   if (tmp < 1)
6135     {
6136       edir->datalabel_got.refcount = eind->datalabel_got.refcount;
6137       eind->datalabel_got.refcount = tmp;
6138     }
6139   else
6140     BFD_ASSERT (eind->datalabel_got.refcount < 1);
6141 #endif
6142
6143   if (ind->root.type == bfd_link_hash_indirect
6144       && dir->got.refcount <= 0)
6145     {
6146       edir->tls_type = eind->tls_type;
6147       eind->tls_type = GOT_UNKNOWN;
6148     }
6149
6150   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
6151 }
6152
6153 static int
6154 sh_elf_optimized_tls_reloc (info, r_type, is_local)
6155      struct bfd_link_info *info;
6156      int r_type;
6157      int is_local;
6158 {
6159   if (info->shared)
6160     return r_type;
6161
6162   switch (r_type)
6163     {
6164     case R_SH_TLS_GD_32:
6165     case R_SH_TLS_IE_32:
6166       if (is_local)
6167         return R_SH_TLS_LE_32;
6168       return R_SH_TLS_IE_32;
6169     case R_SH_TLS_LD_32:
6170       return R_SH_TLS_LE_32;
6171     }
6172
6173   return r_type;
6174 }
6175
6176 /* Look through the relocs for a section during the first phase.
6177    Since we don't do .gots or .plts, we just need to consider the
6178    virtual table relocs for gc.  */
6179
6180 static boolean
6181 sh_elf_check_relocs (abfd, info, sec, relocs)
6182      bfd *abfd;
6183      struct bfd_link_info *info;
6184      asection *sec;
6185      const Elf_Internal_Rela *relocs;
6186 {
6187   Elf_Internal_Shdr *symtab_hdr;
6188   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6189   struct elf_sh_link_hash_table *htab;
6190   const Elf_Internal_Rela *rel;
6191   const Elf_Internal_Rela *rel_end;
6192   bfd *dynobj;
6193   bfd_vma *local_got_offsets;
6194   asection *sgot;
6195   asection *srelgot;
6196   asection *sreloc;
6197   unsigned int r_type;
6198   int tls_type, old_tls_type;
6199
6200   sgot = NULL;
6201   srelgot = NULL;
6202   sreloc = NULL;
6203
6204   if (info->relocateable)
6205     return true;
6206
6207   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6208   sym_hashes = elf_sym_hashes (abfd);
6209   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
6210   if (!elf_bad_symtab (abfd))
6211     sym_hashes_end -= symtab_hdr->sh_info;
6212
6213   htab = sh_elf_hash_table (info);
6214   dynobj = htab->root.dynobj;
6215   local_got_offsets = elf_local_got_offsets (abfd);
6216
6217   rel_end = relocs + sec->reloc_count;
6218   for (rel = relocs; rel < rel_end; rel++)
6219     {
6220       struct elf_link_hash_entry *h;
6221       unsigned long r_symndx;
6222 #ifdef INCLUDE_SHMEDIA
6223       int seen_stt_datalabel = 0;
6224 #endif
6225
6226       r_symndx = ELF32_R_SYM (rel->r_info);
6227       r_type = ELF32_R_TYPE (rel->r_info);
6228
6229       if (r_symndx < symtab_hdr->sh_info)
6230         h = NULL;
6231       else
6232         {
6233           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6234 #ifdef INCLUDE_SHMEDIA
6235           while (h->root.type == bfd_link_hash_indirect
6236                  || h->root.type == bfd_link_hash_warning)
6237             {
6238               seen_stt_datalabel |= h->type == STT_DATALABEL;
6239               h = (struct elf_link_hash_entry *) h->root.u.i.link;
6240             }
6241 #endif
6242         }
6243
6244       r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
6245       if (! info->shared
6246           && r_type == R_SH_TLS_IE_32
6247           && h != NULL
6248           && h->root.type != bfd_link_hash_undefined
6249           && h->root.type != bfd_link_hash_undefweak
6250           && (h->dynindx == -1
6251               || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
6252         r_type = R_SH_TLS_LE_32;
6253
6254       /* Some relocs require a global offset table.  */
6255       if (htab->sgot == NULL)
6256         {
6257           switch (r_type)
6258             {
6259             case R_SH_GOTPLT32:
6260             case R_SH_GOT32:
6261             case R_SH_GOTOFF:
6262             case R_SH_GOTPC:
6263 #ifdef INCLUDE_SHMEDIA
6264             case R_SH_GOTPLT_LOW16:
6265             case R_SH_GOTPLT_MEDLOW16:
6266             case R_SH_GOTPLT_MEDHI16:
6267             case R_SH_GOTPLT_HI16:
6268             case R_SH_GOTPLT10BY4:
6269             case R_SH_GOTPLT10BY8:
6270             case R_SH_GOT_LOW16:
6271             case R_SH_GOT_MEDLOW16:
6272             case R_SH_GOT_MEDHI16:
6273             case R_SH_GOT_HI16:
6274             case R_SH_GOT10BY4:
6275             case R_SH_GOT10BY8:
6276             case R_SH_GOTOFF_LOW16:
6277             case R_SH_GOTOFF_MEDLOW16:
6278             case R_SH_GOTOFF_MEDHI16:
6279             case R_SH_GOTOFF_HI16:
6280             case R_SH_GOTPC_LOW16:
6281             case R_SH_GOTPC_MEDLOW16:
6282             case R_SH_GOTPC_MEDHI16:
6283             case R_SH_GOTPC_HI16:
6284 #endif
6285             case R_SH_TLS_GD_32:
6286             case R_SH_TLS_LD_32:
6287             case R_SH_TLS_IE_32:
6288               if (dynobj == NULL)
6289                 htab->root.dynobj = dynobj = abfd;
6290               if (! create_got_section (dynobj, info))
6291                 return false;
6292               break;
6293
6294             default:
6295               break;
6296             }
6297         }
6298
6299       switch (r_type)
6300         {
6301           /* This relocation describes the C++ object vtable hierarchy.
6302              Reconstruct it for later use during GC.  */
6303         case R_SH_GNU_VTINHERIT:
6304           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6305             return false;
6306           break;
6307
6308           /* This relocation describes which C++ vtable entries are actually
6309              used.  Record for later use during GC.  */
6310         case R_SH_GNU_VTENTRY:
6311           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6312             return false;
6313           break;
6314
6315         force_got:
6316         case R_SH_TLS_IE_32:
6317           if (info->shared)
6318             info->flags |= DF_STATIC_TLS;
6319
6320           /* FALLTHROUGH */
6321         case R_SH_TLS_GD_32:
6322         case R_SH_GOT32:
6323 #ifdef INCLUDE_SHMEDIA
6324         case R_SH_GOT_LOW16:
6325         case R_SH_GOT_MEDLOW16:
6326         case R_SH_GOT_MEDHI16:
6327         case R_SH_GOT_HI16:
6328         case R_SH_GOT10BY4:
6329         case R_SH_GOT10BY8:
6330 #endif
6331           switch (r_type)
6332             {
6333             default:
6334               tls_type = GOT_NORMAL;
6335               break;
6336             case R_SH_TLS_GD_32:
6337               tls_type = GOT_TLS_GD;
6338               break;
6339             case R_SH_TLS_IE_32:
6340               tls_type = GOT_TLS_IE;
6341               break;
6342             }
6343
6344           if (h != NULL)
6345             {
6346 #ifdef INCLUDE_SHMEDIA
6347               if (seen_stt_datalabel)
6348                 {
6349                   struct elf_sh_link_hash_entry *eh =
6350                     (struct elf_sh_link_hash_entry *)h;
6351
6352                   eh->datalabel_got.refcount += 1;
6353                 }
6354               else
6355 #endif
6356                 h->got.refcount += 1;
6357               old_tls_type = sh_elf_hash_entry (h)->tls_type;
6358             }
6359           else
6360             {
6361               bfd_signed_vma *local_got_refcounts;
6362
6363               /* This is a global offset table entry for a local
6364                  symbol.  */
6365               local_got_refcounts = elf_local_got_refcounts (abfd);
6366               if (local_got_refcounts == NULL)
6367                 {
6368                   bfd_size_type size;
6369
6370                   size = symtab_hdr->sh_info;
6371                   size *= sizeof (bfd_signed_vma);
6372 #ifdef INCLUDE_SHMEDIA
6373                   /* Reserve space for both the datalabel and
6374                      codelabel local GOT offsets.  */
6375                   size *= 2;
6376 #endif
6377                   size += symtab_hdr->sh_info;
6378                   local_got_refcounts = ((bfd_signed_vma *)
6379                                          bfd_zalloc (abfd, size));
6380                   if (local_got_refcounts == NULL)
6381                     return false;
6382                   elf_local_got_refcounts (abfd) = local_got_refcounts;
6383 #ifdef  INCLUDE_SHMEDIA
6384                   /* Take care of both the datalabel and codelabel local
6385                      GOT offsets.  */
6386                   sh_elf_local_got_tls_type (abfd)
6387                     = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
6388 #else
6389                   sh_elf_local_got_tls_type (abfd)
6390                     = (char *) (local_got_refcounts + symtab_hdr->sh_info);
6391 #endif
6392                 }
6393 #ifdef INCLUDE_SHMEDIA
6394               if (rel->r_addend & 1)
6395                 local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
6396               else
6397 #endif
6398                 local_got_refcounts[r_symndx] += 1;
6399               old_tls_type = sh_elf_local_got_tls_type (abfd) [r_symndx];
6400             }
6401
6402           /* If a TLS symbol is accessed using IE at least once,
6403              there is no point to use dynamic model for it.  */
6404           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
6405               && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
6406             {
6407               if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
6408                 tls_type = GOT_TLS_IE;
6409               else
6410                 {
6411                   (*_bfd_error_handler)
6412                     (_("%s: `%s' accessed both as normal and thread local symbol"),
6413                      bfd_archive_filename (abfd), h->root.root.string);
6414                   return false;
6415                 }
6416             }
6417
6418           if (old_tls_type != tls_type)
6419             {
6420               if (h != NULL)
6421                 sh_elf_hash_entry (h)->tls_type = tls_type;
6422               else
6423                 sh_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
6424             }
6425
6426           break;
6427
6428         case R_SH_TLS_LD_32:
6429           sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
6430           break;
6431
6432         case R_SH_GOTPLT32:
6433 #ifdef INCLUDE_SHMEDIA
6434         case R_SH_GOTPLT_LOW16:
6435         case R_SH_GOTPLT_MEDLOW16:
6436         case R_SH_GOTPLT_MEDHI16:
6437         case R_SH_GOTPLT_HI16:
6438         case R_SH_GOTPLT10BY4:
6439         case R_SH_GOTPLT10BY8:
6440 #endif
6441           /* If this is a local symbol, we resolve it directly without
6442              creating a procedure linkage table entry.  */
6443
6444           if (h == NULL
6445               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
6446               || ! info->shared
6447               || info->symbolic
6448               || h->dynindx == -1)
6449             goto force_got;
6450
6451           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
6452           h->plt.refcount += 1;
6453           ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
6454
6455           break;
6456
6457         case R_SH_PLT32:
6458 #ifdef INCLUDE_SHMEDIA
6459         case R_SH_PLT_LOW16:
6460         case R_SH_PLT_MEDLOW16:
6461         case R_SH_PLT_MEDHI16:
6462         case R_SH_PLT_HI16:
6463 #endif
6464           /* This symbol requires a procedure linkage table entry.  We
6465              actually build the entry in adjust_dynamic_symbol,
6466              because this might be a case of linking PIC code which is
6467              never referenced by a dynamic object, in which case we
6468              don't need to generate a procedure linkage table entry
6469              after all.  */
6470
6471           /* If this is a local symbol, we resolve it directly without
6472              creating a procedure linkage table entry.  */
6473           if (h == NULL)
6474             continue;
6475
6476           if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
6477             break;
6478
6479           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
6480           h->plt.refcount += 1;
6481           break;
6482
6483         case R_SH_DIR32:
6484         case R_SH_REL32:
6485           if (h != NULL && ! info->shared)
6486             {
6487               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
6488               h->plt.refcount += 1;
6489             }
6490
6491           /* If we are creating a shared library, and this is a reloc
6492              against a global symbol, or a non PC relative reloc
6493              against a local symbol, then we need to copy the reloc
6494              into the shared library.  However, if we are linking with
6495              -Bsymbolic, we do not need to copy a reloc against a
6496              global symbol which is defined in an object we are
6497              including in the link (i.e., DEF_REGULAR is set).  At
6498              this point we have not seen all the input files, so it is
6499              possible that DEF_REGULAR is not set now but will be set
6500              later (it is never cleared).  We account for that
6501              possibility below by storing information in the
6502              dyn_relocs field of the hash table entry. A similar
6503              situation occurs when creating shared libraries and symbol
6504              visibility changes render the symbol local.
6505
6506              If on the other hand, we are creating an executable, we
6507              may need to keep relocations for symbols satisfied by a
6508              dynamic library if we manage to avoid copy relocs for the
6509              symbol.  */
6510           if ((info->shared
6511                && (sec->flags & SEC_ALLOC) != 0
6512                && (r_type != R_SH_REL32
6513                    || (h != NULL
6514                        && (! info->symbolic
6515                            || h->root.type == bfd_link_hash_defweak
6516                            || (h->elf_link_hash_flags
6517                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
6518               || (! info->shared
6519                   && (sec->flags & SEC_ALLOC) != 0
6520                   && h != NULL
6521                   && (h->root.type == bfd_link_hash_defweak
6522                       || (h->elf_link_hash_flags
6523                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6524             {
6525               struct elf_sh_dyn_relocs *p;
6526               struct elf_sh_dyn_relocs **head;
6527
6528               if (dynobj == NULL)
6529                 htab->root.dynobj = dynobj = abfd;
6530
6531               /* When creating a shared object, we must copy these
6532                  reloc types into the output file.  We create a reloc
6533                  section in dynobj and make room for this reloc.  */
6534               if (sreloc == NULL)
6535                 {
6536                   const char *name;
6537
6538                   name = (bfd_elf_string_from_elf_section
6539                           (abfd,
6540                            elf_elfheader (abfd)->e_shstrndx,
6541                            elf_section_data (sec)->rel_hdr.sh_name));
6542                   if (name == NULL)
6543                     return false;
6544
6545                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6546                               && strcmp (bfd_get_section_name (abfd, sec),
6547                                          name + 5) == 0);
6548
6549                   sreloc = bfd_get_section_by_name (dynobj, name);
6550                   if (sreloc == NULL)
6551                     {
6552                       flagword flags;
6553
6554                       sreloc = bfd_make_section (dynobj, name);
6555                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
6556                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6557                       if ((sec->flags & SEC_ALLOC) != 0)
6558                         flags |= SEC_ALLOC | SEC_LOAD;
6559                       if (sreloc == NULL
6560                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
6561                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6562                         return false;
6563                     }
6564                   if (sec->flags & SEC_READONLY)
6565                     info->flags |= DF_TEXTREL;
6566                   elf_section_data (sec)->sreloc = sreloc;
6567                 }
6568
6569               /* If this is a global symbol, we count the number of
6570                  relocations we need for this symbol.  */
6571               if (h != NULL)
6572                 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6573               else
6574                 {
6575                   asection *s;
6576
6577                   /* Track dynamic relocs needed for local syms too.  */
6578                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6579                                                  sec, r_symndx);
6580                   if (s == NULL)
6581                     return false;
6582
6583                   head = ((struct elf_sh_dyn_relocs **)
6584                           &elf_section_data (s)->local_dynrel);
6585                 }
6586
6587               p = *head;
6588               if (p == NULL || p->sec != sec)
6589                 {
6590                   bfd_size_type amt = sizeof (*p);
6591                   p = ((struct elf_sh_dyn_relocs *) bfd_alloc (dynobj, amt));
6592                   if (p == NULL)
6593                     return false;
6594                   p->next = *head;
6595                   *head = p;
6596                   p->sec = sec;
6597                   p->count = 0;
6598                   p->pc_count = 0;
6599                 }
6600
6601               p->count += 1;
6602               if (r_type == R_SH_REL32)
6603                 p->pc_count += 1;
6604             }
6605
6606           break;
6607
6608         case R_SH_TLS_LE_32:
6609           if (info->shared)
6610             {
6611               (*_bfd_error_handler) (_("%s: TLS local exec code cannot be linked into shared objects"),
6612                                      bfd_archive_filename (abfd));
6613               return false;
6614             }
6615
6616           if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_LD_32)
6617             break;
6618
6619           /* FALLTHROUGH */
6620         case R_SH_TLS_LDO_32:
6621           /* We make a R_SH_TLS_TPOFF32 relocation. Count it as a
6622              copy relocation.  */
6623           if (! info->shared)
6624             {
6625               struct elf_sh_dyn_relocs *p;
6626               struct elf_sh_dyn_relocs **head;
6627
6628               if (dynobj == NULL)
6629                 htab->root.dynobj = dynobj = abfd;
6630
6631               if (sreloc == NULL)
6632                 {
6633                   const char *name;
6634
6635                   name = (bfd_elf_string_from_elf_section
6636                           (abfd,
6637                            elf_elfheader (abfd)->e_shstrndx,
6638                            elf_section_data (sec)->rel_hdr.sh_name));
6639                   if (name == NULL)
6640                     return false;
6641
6642                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6643                               && strcmp (bfd_get_section_name (abfd, sec),
6644                                          name + 5) == 0);
6645
6646                   sreloc = bfd_get_section_by_name (dynobj, name);
6647                   if (sreloc == NULL)
6648                     {
6649                       flagword flags;
6650
6651                       sreloc = bfd_make_section (dynobj, name);
6652                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
6653                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6654                       if ((sec->flags & SEC_ALLOC) != 0)
6655                         flags |= SEC_ALLOC | SEC_LOAD;
6656                       if (sreloc == NULL
6657                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
6658                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6659                         return false;
6660                     }
6661                   elf_section_data (sec)->sreloc = sreloc;
6662                   if (sec->flags & SEC_READONLY)
6663                     info->flags |= DF_TEXTREL;
6664                 }
6665
6666               /* If this is a global symbol, we count the number of
6667                  relocations we need for this symbol.  */
6668               if (h != NULL)
6669                 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6670               else
6671                 {
6672                   asection *s;
6673
6674                   /* Track dynamic relocs needed for local syms too.  */
6675                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6676                                                  sec, r_symndx);
6677                   if (s == NULL)
6678                     return false;
6679
6680                   head = ((struct elf_sh_dyn_relocs **)
6681                           &elf_section_data (s)->local_dynrel);
6682                 }
6683
6684               p = *head;
6685               if (p == NULL || p->sec != sec)
6686                 {
6687                   bfd_size_type amt = sizeof (*p);
6688                   p = ((struct elf_sh_dyn_relocs *) bfd_alloc (dynobj, amt));
6689                   if (p == NULL)
6690                     return false;
6691                   p->next = *head;
6692                   *head = p;
6693                   p->sec = sec;
6694                   p->count = 0;
6695                   p->pc_count = 0;
6696                 }
6697
6698               p->count += 1;
6699               if (h)
6700                 sh_elf_hash_entry (h)->tls_tpoff32 = true;
6701             }
6702           break;
6703
6704         default:
6705           break;
6706         }
6707     }
6708
6709   return true;
6710 }
6711
6712 #ifndef sh_elf_set_mach_from_flags
6713 static boolean
6714 sh_elf_set_mach_from_flags (abfd)
6715      bfd *abfd;
6716 {
6717   flagword flags = elf_elfheader (abfd)->e_flags;
6718
6719   switch (flags & EF_SH_MACH_MASK)
6720     {
6721     case EF_SH1:
6722       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
6723       break;
6724     case EF_SH2:
6725       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
6726       break;
6727     case EF_SH_DSP:
6728       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
6729       break;
6730     case EF_SH3:
6731       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
6732       break;
6733     case EF_SH3_DSP:
6734       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
6735       break;
6736     case EF_SH3E:
6737       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
6738       break;
6739     case EF_SH_UNKNOWN:
6740     case EF_SH4:
6741       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
6742       break;
6743     default:
6744       return false;
6745     }
6746   return true;
6747 }
6748 #endif /* not sh_elf_set_mach_from_flags */
6749
6750 #ifndef sh_elf_set_private_flags
6751 /* Function to keep SH specific file flags.  */
6752
6753 static boolean
6754 sh_elf_set_private_flags (abfd, flags)
6755      bfd *abfd;
6756      flagword flags;
6757 {
6758   BFD_ASSERT (! elf_flags_init (abfd)
6759               || elf_elfheader (abfd)->e_flags == flags);
6760
6761   elf_elfheader (abfd)->e_flags = flags;
6762   elf_flags_init (abfd) = true;
6763   return sh_elf_set_mach_from_flags (abfd);
6764 }
6765 #endif /* not sh_elf_set_private_flags */
6766
6767 #ifndef sh_elf_copy_private_data
6768 /* Copy backend specific data from one object module to another */
6769
6770 static boolean
6771 sh_elf_copy_private_data (ibfd, obfd)
6772      bfd * ibfd;
6773      bfd * obfd;
6774 {
6775   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6776       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6777     return true;
6778
6779   return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
6780 }
6781 #endif /* not sh_elf_copy_private_data */
6782
6783 #ifndef sh_elf_merge_private_data
6784 /* This routine checks for linking big and little endian objects
6785    together, and for linking sh-dsp with sh3e / sh4 objects.  */
6786
6787 static boolean
6788 sh_elf_merge_private_data (ibfd, obfd)
6789      bfd *ibfd;
6790      bfd *obfd;
6791 {
6792   flagword old_flags, new_flags;
6793
6794   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
6795     return false;
6796
6797   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6798       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6799     return true;
6800
6801   if (! elf_flags_init (obfd))
6802     {
6803       /* This happens when ld starts out with a 'blank' output file.  */
6804       elf_flags_init (obfd) = true;
6805       elf_elfheader (obfd)->e_flags = EF_SH1;
6806     }
6807   old_flags = elf_elfheader (obfd)->e_flags;
6808   new_flags = elf_elfheader (ibfd)->e_flags;
6809   if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
6810       || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
6811     {
6812       (*_bfd_error_handler)
6813         ("%s: uses %s instructions while previous modules use %s instructions",
6814          bfd_archive_filename (ibfd),
6815          EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
6816          EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
6817       bfd_set_error (bfd_error_bad_value);
6818       return false;
6819     }
6820   elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
6821
6822   return sh_elf_set_mach_from_flags (obfd);
6823 }
6824 #endif /* not sh_elf_merge_private_data */
6825
6826 /* Override the generic function because we need to store sh_elf_obj_tdata
6827    as the specific tdata.  We set also the machine architecture from flags
6828    here.  */
6829
6830 static boolean
6831 sh_elf_object_p (abfd)
6832   bfd *abfd;
6833 {
6834   struct sh_elf_obj_tdata *new_tdata;
6835   bfd_size_type amt = sizeof (struct sh_elf_obj_tdata);
6836
6837   if (sh_elf_set_mach_from_flags (abfd) == false)
6838     return false;
6839
6840   /* Allocate our special target data.  */
6841   new_tdata = bfd_zalloc (abfd, amt);
6842   if (new_tdata == NULL)
6843     return false;
6844   new_tdata->root = *abfd->tdata.elf_obj_data;
6845   abfd->tdata.any = new_tdata;
6846   return true;
6847 }
6848
6849 /* Finish up dynamic symbol handling.  We set the contents of various
6850    dynamic sections here.  */
6851
6852 static boolean
6853 sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
6854      bfd *output_bfd;
6855      struct bfd_link_info *info;
6856      struct elf_link_hash_entry *h;
6857      Elf_Internal_Sym *sym;
6858 {
6859   struct elf_sh_link_hash_table *htab;
6860   bfd *dynobj;
6861
6862   htab = sh_elf_hash_table (info);
6863   dynobj = htab->root.dynobj;
6864
6865   if (h->plt.offset != (bfd_vma) -1)
6866     {
6867       asection *splt;
6868       asection *sgot;
6869       asection *srel;
6870
6871       bfd_vma plt_index;
6872       bfd_vma got_offset;
6873       Elf_Internal_Rela rel;
6874       bfd_byte *loc;
6875
6876       /* This symbol has an entry in the procedure linkage table.  Set
6877          it up.  */
6878
6879       BFD_ASSERT (h->dynindx != -1);
6880
6881       splt = htab->splt;
6882       sgot = htab->sgotplt;
6883       srel = htab->srelplt;
6884       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
6885
6886       /* Get the index in the procedure linkage table which
6887          corresponds to this symbol.  This is the index of this symbol
6888          in all the symbols for which we are making plt entries.  The
6889          first entry in the procedure linkage table is reserved.  */
6890       plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
6891
6892       /* Get the offset into the .got table of the entry that
6893          corresponds to this function.  Each .got entry is 4 bytes.
6894          The first three are reserved.  */
6895       got_offset = (plt_index + 3) * 4;
6896
6897 #ifdef GOT_BIAS
6898       if (info->shared)
6899         got_offset -= GOT_BIAS;
6900 #endif
6901
6902       /* Fill in the entry in the procedure linkage table.  */
6903       if (! info->shared)
6904         {
6905           if (elf_sh_plt_entry == NULL)
6906             {
6907               elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
6908                                   elf_sh_plt_entry_be : elf_sh_plt_entry_le);
6909             }
6910           memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
6911                   elf_sh_sizeof_plt (info));
6912 #ifdef INCLUDE_SHMEDIA
6913           movi_shori_putval (output_bfd,
6914                              (sgot->output_section->vma
6915                               + sgot->output_offset
6916                               + got_offset),
6917                              (splt->contents + h->plt.offset
6918                               + elf_sh_plt_symbol_offset (info)));
6919
6920           /* Set bottom bit because its for a branch to SHmedia */
6921           movi_shori_putval (output_bfd,
6922                              (splt->output_section->vma + splt->output_offset)
6923                              | 1,
6924                              (splt->contents + h->plt.offset
6925                               + elf_sh_plt_plt0_offset (info)));
6926 #else
6927           bfd_put_32 (output_bfd,
6928                       (sgot->output_section->vma
6929                        + sgot->output_offset
6930                        + got_offset),
6931                       (splt->contents + h->plt.offset
6932                        + elf_sh_plt_symbol_offset (info)));
6933
6934           bfd_put_32 (output_bfd,
6935                       (splt->output_section->vma + splt->output_offset),
6936                       (splt->contents + h->plt.offset
6937                        + elf_sh_plt_plt0_offset (info)));
6938 #endif
6939         }
6940       else
6941         {
6942           if (elf_sh_pic_plt_entry == NULL)
6943             {
6944               elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
6945                                       elf_sh_pic_plt_entry_be :
6946                                       elf_sh_pic_plt_entry_le);
6947             }
6948           memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
6949                   elf_sh_sizeof_plt (info));
6950 #ifdef INCLUDE_SHMEDIA
6951           movi_shori_putval (output_bfd, got_offset,
6952                              (splt->contents + h->plt.offset
6953                               + elf_sh_plt_symbol_offset (info)));
6954 #else
6955           bfd_put_32 (output_bfd, got_offset,
6956                       (splt->contents + h->plt.offset
6957                        + elf_sh_plt_symbol_offset (info)));
6958 #endif
6959         }
6960
6961 #ifdef GOT_BIAS
6962       if (info->shared)
6963         got_offset += GOT_BIAS;
6964 #endif
6965
6966 #ifdef INCLUDE_SHMEDIA
6967       movi_shori_putval (output_bfd,
6968                          plt_index * sizeof (Elf32_External_Rela),
6969                          (splt->contents + h->plt.offset
6970                           + elf_sh_plt_reloc_offset (info)));
6971 #else
6972       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
6973                   (splt->contents + h->plt.offset
6974                    + elf_sh_plt_reloc_offset (info)));
6975 #endif
6976
6977       /* Fill in the entry in the global offset table.  */
6978       bfd_put_32 (output_bfd,
6979                   (splt->output_section->vma
6980                    + splt->output_offset
6981                    + h->plt.offset
6982                    + elf_sh_plt_temp_offset (info)),
6983                   sgot->contents + got_offset);
6984
6985       /* Fill in the entry in the .rela.plt section.  */
6986       rel.r_offset = (sgot->output_section->vma
6987                       + sgot->output_offset
6988                       + got_offset);
6989       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
6990       rel.r_addend = 0;
6991 #ifdef GOT_BIAS
6992       rel.r_addend = GOT_BIAS;
6993 #endif
6994       loc = srel->contents + plt_index * sizeof (Elf32_External_Rela);
6995       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6996
6997       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
6998         {
6999           /* Mark the symbol as undefined, rather than as defined in
7000              the .plt section.  Leave the value alone.  */
7001           sym->st_shndx = SHN_UNDEF;
7002         }
7003     }
7004
7005   if (h->got.offset != (bfd_vma) -1
7006       && sh_elf_hash_entry (h)->tls_type != GOT_TLS_GD
7007       && sh_elf_hash_entry (h)->tls_type != GOT_TLS_IE)
7008     {
7009       asection *sgot;
7010       asection *srel;
7011       Elf_Internal_Rela rel;
7012       bfd_byte *loc;
7013
7014       /* This symbol has an entry in the global offset table.  Set it
7015          up.  */
7016
7017       sgot = htab->sgot;
7018       srel = htab->srelgot;
7019       BFD_ASSERT (sgot != NULL && srel != NULL);
7020
7021       rel.r_offset = (sgot->output_section->vma
7022                       + sgot->output_offset
7023                       + (h->got.offset &~ (bfd_vma) 1));
7024
7025       /* If this is a static link, or it is a -Bsymbolic link and the
7026          symbol is defined locally or was forced to be local because
7027          of a version file, we just want to emit a RELATIVE reloc.
7028          The entry in the global offset table will already have been
7029          initialized in the relocate_section function.  */
7030       if (info->shared
7031           && (info->symbolic
7032               || h->dynindx == -1
7033               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
7034           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
7035         {
7036           rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7037           rel.r_addend = (h->root.u.def.value
7038                           + h->root.u.def.section->output_section->vma
7039                           + h->root.u.def.section->output_offset);
7040         }
7041       else
7042         {
7043           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
7044           rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7045           rel.r_addend = 0;
7046         }
7047
7048       loc = srel->contents;
7049       loc += srel->reloc_count++ * sizeof (Elf32_External_Rela);
7050       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7051     }
7052
7053 #ifdef INCLUDE_SHMEDIA
7054   {
7055     struct elf_sh_link_hash_entry *eh;
7056
7057     eh = (struct elf_sh_link_hash_entry *) h;
7058     if (eh->datalabel_got.offset != (bfd_vma) -1)
7059       {
7060         asection *sgot;
7061         asection *srel;
7062         Elf_Internal_Rela rel;
7063         bfd_byte *loc;
7064
7065         /* This symbol has a datalabel entry in the global offset table.
7066            Set it up.  */
7067
7068         sgot = htab->sgot;
7069         srel = htab->srelgot;
7070         BFD_ASSERT (sgot != NULL && srel != NULL);
7071
7072         rel.r_offset = (sgot->output_section->vma
7073                         + sgot->output_offset
7074                         + (eh->datalabel_got.offset &~ (bfd_vma) 1));
7075
7076         /* If this is a static link, or it is a -Bsymbolic link and the
7077            symbol is defined locally or was forced to be local because
7078            of a version file, we just want to emit a RELATIVE reloc.
7079            The entry in the global offset table will already have been
7080            initialized in the relocate_section function.  */
7081         if (info->shared
7082             && (info->symbolic
7083                 || h->dynindx == -1
7084                 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
7085             && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
7086           {
7087             rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7088             rel.r_addend = (h->root.u.def.value
7089                             + h->root.u.def.section->output_section->vma
7090                             + h->root.u.def.section->output_offset);
7091           }
7092         else
7093           {
7094             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents
7095                         + eh->datalabel_got.offset);
7096             rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7097             rel.r_addend = 0;
7098           }
7099
7100         loc = srel->contents;
7101         loc += srel->reloc_count++ * sizeof (Elf32_External_Rela);
7102         bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7103       }
7104   }
7105 #endif
7106
7107   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
7108     {
7109       asection *s;
7110       Elf_Internal_Rela rel;
7111       bfd_byte *loc;
7112
7113       /* This symbol needs a copy reloc.  Set it up.  */
7114
7115       BFD_ASSERT (h->dynindx != -1
7116                   && (h->root.type == bfd_link_hash_defined
7117                       || h->root.type == bfd_link_hash_defweak));
7118
7119       s = bfd_get_section_by_name (h->root.u.def.section->owner,
7120                                    ".rela.bss");
7121       BFD_ASSERT (s != NULL);
7122
7123       rel.r_offset = (h->root.u.def.value
7124                       + h->root.u.def.section->output_section->vma
7125                       + h->root.u.def.section->output_offset);
7126       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
7127       rel.r_addend = 0;
7128       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
7129       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7130     }
7131
7132   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
7133   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7134       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7135     sym->st_shndx = SHN_ABS;
7136
7137   return true;
7138 }
7139
7140 /* Finish up the dynamic sections.  */
7141
7142 static boolean
7143 sh_elf_finish_dynamic_sections (output_bfd, info)
7144      bfd *output_bfd;
7145      struct bfd_link_info *info;
7146 {
7147   struct elf_sh_link_hash_table *htab;
7148   bfd *dynobj;
7149   asection *sgot;
7150   asection *sdyn;
7151
7152   htab = sh_elf_hash_table (info);
7153   dynobj = htab->root.dynobj;
7154
7155   sgot = htab->sgotplt;
7156   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7157
7158   if (htab->root.dynamic_sections_created)
7159     {
7160       asection *splt;
7161       Elf32_External_Dyn *dyncon, *dynconend;
7162
7163       BFD_ASSERT (sgot != NULL && sdyn != NULL);
7164
7165       dyncon = (Elf32_External_Dyn *) sdyn->contents;
7166       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
7167       for (; dyncon < dynconend; dyncon++)
7168         {
7169           Elf_Internal_Dyn dyn;
7170           asection *s;
7171 #ifdef INCLUDE_SHMEDIA
7172           const char *name;
7173 #endif
7174
7175           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
7176
7177           switch (dyn.d_tag)
7178             {
7179             default:
7180               break;
7181
7182 #ifdef INCLUDE_SHMEDIA
7183             case DT_INIT:
7184               name = info->init_function;
7185               goto get_sym;
7186
7187             case DT_FINI:
7188               name = info->fini_function;
7189             get_sym:
7190               if (dyn.d_un.d_val != 0)
7191                 {
7192                   struct elf_link_hash_entry *h;
7193
7194                   h = elf_link_hash_lookup (&htab->root, name,
7195                                             false, false, true);
7196                   if (h != NULL && (h->other & STO_SH5_ISA32))
7197                     {
7198                       dyn.d_un.d_val |= 1;
7199                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7200                     }
7201                 }
7202               break;
7203 #endif
7204
7205             case DT_PLTGOT:
7206               s = htab->sgot->output_section;
7207               goto get_vma;
7208
7209             case DT_JMPREL:
7210               s = htab->srelplt->output_section;
7211             get_vma:
7212               BFD_ASSERT (s != NULL);
7213               dyn.d_un.d_ptr = s->vma;
7214               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7215               break;
7216
7217             case DT_PLTRELSZ:
7218               s = htab->srelplt->output_section;
7219               BFD_ASSERT (s != NULL);
7220               if (s->_cooked_size != 0)
7221                 dyn.d_un.d_val = s->_cooked_size;
7222               else
7223                 dyn.d_un.d_val = s->_raw_size;
7224               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7225               break;
7226
7227             case DT_RELASZ:
7228               /* My reading of the SVR4 ABI indicates that the
7229                  procedure linkage table relocs (DT_JMPREL) should be
7230                  included in the overall relocs (DT_RELA).  This is
7231                  what Solaris does.  However, UnixWare can not handle
7232                  that case.  Therefore, we override the DT_RELASZ entry
7233                  here to make it not include the JMPREL relocs.  Since
7234                  the linker script arranges for .rela.plt to follow all
7235                  other relocation sections, we don't have to worry
7236                  about changing the DT_RELA entry.  */
7237               if (htab->srelplt != NULL)
7238                 {
7239                   s = htab->srelplt->output_section;
7240                   if (s->_cooked_size != 0)
7241                     dyn.d_un.d_val -= s->_cooked_size;
7242                   else
7243                     dyn.d_un.d_val -= s->_raw_size;
7244                 }
7245               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7246               break;
7247             }
7248         }
7249
7250       /* Fill in the first entry in the procedure linkage table.  */
7251       splt = htab->splt;
7252       if (splt && splt->_raw_size > 0)
7253         {
7254           if (info->shared)
7255             {
7256               if (elf_sh_pic_plt_entry == NULL)
7257                 {
7258                   elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
7259                                           elf_sh_pic_plt_entry_be :
7260                                           elf_sh_pic_plt_entry_le);
7261                 }
7262               memcpy (splt->contents, elf_sh_pic_plt_entry,
7263                       elf_sh_sizeof_plt (info));
7264             }
7265           else
7266             {
7267               if (elf_sh_plt0_entry == NULL)
7268                 {
7269                   elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
7270                                        elf_sh_plt0_entry_be :
7271                                        elf_sh_plt0_entry_le);
7272                 }
7273               memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
7274 #ifdef INCLUDE_SHMEDIA
7275               movi_shori_putval (output_bfd,
7276                                  sgot->output_section->vma
7277                                  + sgot->output_offset,
7278                                  splt->contents
7279                                  + elf_sh_plt0_gotplt_offset (info));
7280 #else
7281               bfd_put_32 (output_bfd,
7282                           sgot->output_section->vma + sgot->output_offset + 4,
7283                           splt->contents + elf_sh_plt0_gotid_offset (info));
7284               bfd_put_32 (output_bfd,
7285                           sgot->output_section->vma + sgot->output_offset + 8,
7286                           splt->contents + elf_sh_plt0_linker_offset (info));
7287 #endif
7288             }
7289
7290           /* UnixWare sets the entsize of .plt to 4, although that doesn't
7291              really seem like the right value.  */
7292           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7293         }
7294     }
7295
7296   /* Fill in the first three entries in the global offset table.  */
7297   if (sgot && sgot->_raw_size > 0)
7298     {
7299       if (sdyn == NULL)
7300         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7301       else
7302         bfd_put_32 (output_bfd,
7303                     sdyn->output_section->vma + sdyn->output_offset,
7304                     sgot->contents);
7305       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7306       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7307
7308       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7309     }
7310
7311   return true;
7312 }
7313
7314 static enum elf_reloc_type_class
7315 sh_elf_reloc_type_class (rela)
7316      const Elf_Internal_Rela *rela;
7317 {
7318   switch ((int) ELF32_R_TYPE (rela->r_info))
7319     {
7320     case R_SH_RELATIVE:
7321       return reloc_class_relative;
7322     case R_SH_JMP_SLOT:
7323       return reloc_class_plt;
7324     case R_SH_COPY:
7325       return reloc_class_copy;
7326     default:
7327       return reloc_class_normal;
7328     }
7329 }
7330
7331 /* Support for Linux core dump NOTE sections */
7332 static boolean
7333 elf32_shlin_grok_prstatus (abfd, note)
7334      bfd *abfd;
7335      Elf_Internal_Note *note;
7336 {
7337   int offset;
7338   unsigned int raw_size;
7339
7340   switch (note->descsz)
7341     {
7342       default:
7343         return false;
7344
7345       case 168:         /* Linux/SH */
7346         /* pr_cursig */
7347         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
7348
7349         /* pr_pid */
7350         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
7351
7352         /* pr_reg */
7353         offset = 72;
7354         raw_size = 92;
7355
7356         break;
7357     }
7358
7359   /* Make a ".reg/999" section.  */
7360   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7361                                           raw_size, note->descpos + offset);
7362 }
7363
7364 static boolean
7365 elf32_shlin_grok_psinfo (abfd, note)
7366      bfd *abfd;
7367      Elf_Internal_Note *note;
7368 {
7369   switch (note->descsz)
7370     {
7371       default:
7372         return false;
7373
7374       case 124:         /* Linux/SH elf_prpsinfo */
7375         elf_tdata (abfd)->core_program
7376          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
7377         elf_tdata (abfd)->core_command
7378          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
7379     }
7380
7381   /* Note that for some reason, a spurious space is tacked
7382      onto the end of the args in some (at least one anyway)
7383      implementations, so strip it off if it exists.  */
7384
7385   {
7386     char *command = elf_tdata (abfd)->core_command;
7387     int n = strlen (command);
7388
7389     if (0 < n && command[n - 1] == ' ')
7390       command[n - 1] = '\0';
7391   }
7392
7393   return true;
7394 }
7395
7396 #define TARGET_BIG_SYM          bfd_elf32_sh_vec
7397 #define TARGET_BIG_NAME         "elf32-sh"
7398 #define TARGET_LITTLE_SYM       bfd_elf32_shl_vec
7399 #define TARGET_LITTLE_NAME      "elf32-shl"
7400 #define ELF_ARCH                bfd_arch_sh
7401 #define ELF_MACHINE_CODE        EM_SH
7402 #define ELF_MAXPAGESIZE         128
7403
7404 #define elf_symbol_leading_char '_'
7405
7406 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7407 #define elf_info_to_howto               sh_elf_info_to_howto
7408 #define bfd_elf32_bfd_relax_section     sh_elf_relax_section
7409 #define elf_backend_relocate_section    sh_elf_relocate_section
7410 #define bfd_elf32_bfd_get_relocated_section_contents \
7411                                         sh_elf_get_relocated_section_contents
7412 #define bfd_elf32_mkobject              sh_elf_mkobject
7413 #define elf_backend_object_p            sh_elf_object_p
7414 #define bfd_elf32_bfd_set_private_bfd_flags \
7415                                         sh_elf_set_private_flags
7416 #define bfd_elf32_bfd_copy_private_bfd_data \
7417                                         sh_elf_copy_private_data
7418 #define bfd_elf32_bfd_merge_private_bfd_data \
7419                                         sh_elf_merge_private_data
7420
7421 #define elf_backend_gc_mark_hook        sh_elf_gc_mark_hook
7422 #define elf_backend_gc_sweep_hook       sh_elf_gc_sweep_hook
7423 #define elf_backend_check_relocs        sh_elf_check_relocs
7424 #define elf_backend_copy_indirect_symbol \
7425                                         sh_elf_copy_indirect_symbol
7426 #define elf_backend_create_dynamic_sections \
7427                                         sh_elf_create_dynamic_sections
7428 #define bfd_elf32_bfd_link_hash_table_create \
7429                                         sh_elf_link_hash_table_create
7430 #define elf_backend_adjust_dynamic_symbol \
7431                                         sh_elf_adjust_dynamic_symbol
7432 #define elf_backend_size_dynamic_sections \
7433                                         sh_elf_size_dynamic_sections
7434 #define elf_backend_finish_dynamic_symbol \
7435                                         sh_elf_finish_dynamic_symbol
7436 #define elf_backend_finish_dynamic_sections \
7437                                         sh_elf_finish_dynamic_sections
7438 #define elf_backend_reloc_type_class    sh_elf_reloc_type_class
7439
7440 #define elf_backend_can_gc_sections     1
7441 #define elf_backend_can_refcount        1
7442 #define elf_backend_want_got_plt        1
7443 #define elf_backend_plt_readonly        1
7444 #define elf_backend_want_plt_sym        0
7445 #define elf_backend_got_header_size     12
7446 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
7447
7448 #ifndef INCLUDE_SHMEDIA
7449
7450 #include "elf32-target.h"
7451
7452 /* NetBSD support.  */
7453 #undef  TARGET_BIG_SYM
7454 #define TARGET_BIG_SYM                  bfd_elf32_shnbsd_vec
7455 #undef  TARGET_BIG_NAME
7456 #define TARGET_BIG_NAME                 "elf32-sh-nbsd"
7457 #undef  TARGET_LITTLE_SYM
7458 #define TARGET_LITTLE_SYM               bfd_elf32_shlnbsd_vec
7459 #undef  TARGET_LITTLE_NAME
7460 #define TARGET_LITTLE_NAME              "elf32-shl-nbsd"
7461 #undef  ELF_MAXPAGESIZE
7462 #define ELF_MAXPAGESIZE                 0x10000
7463 #undef  elf_symbol_leading_char
7464 #define elf_symbol_leading_char         0
7465
7466 #define elf32_bed                       elf32_sh_nbsd_bed
7467
7468 #include "elf32-target.h"
7469
7470 #undef  elf32_bed
7471
7472 /* Linux support.  */
7473 #undef  TARGET_BIG_SYM
7474 #define TARGET_BIG_SYM                  bfd_elf32_shblin_vec
7475 #undef  TARGET_BIG_NAME
7476 #define TARGET_BIG_NAME                 "elf32-shbig-linux"
7477 #undef  TARGET_LITTLE_SYM
7478 #define TARGET_LITTLE_SYM               bfd_elf32_shlin_vec
7479 #undef  TARGET_LITTLE_NAME
7480 #define TARGET_LITTLE_NAME              "elf32-sh-linux"
7481
7482 #undef  elf_backend_grok_prstatus
7483 #define elf_backend_grok_prstatus       elf32_shlin_grok_prstatus
7484 #undef  elf_backend_grok_psinfo
7485 #define elf_backend_grok_psinfo         elf32_shlin_grok_psinfo
7486
7487 #define elf32_bed                       elf32_sh_lin_bed
7488
7489 #include "elf32-target.h"
7490
7491 #undef  elf_backend_grok_prstatus
7492 #undef  elf_backend_grok_psinfo
7493 #undef  elf32_bed
7494
7495 #endif /* INCLUDE_SHMEDIA */