bfd/elf32-sh.c

   1 /* Hitachi SH specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   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 bfd_boolean sh_elf_set_private_flags
  38   PARAMS ((bfd *, flagword));
  39 static bfd_boolean sh_elf_copy_private_data
  40   PARAMS ((bfd *, bfd *));
  41 static bfd_boolean sh_elf_merge_private_data
  42   PARAMS ((bfd *, bfd *));
  43 static bfd_boolean sh_elf_set_mach_from_flags
  44   PARAMS ((bfd *));
  45 static bfd_boolean sh_elf_relax_section
  46   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
  47 static bfd_boolean sh_elf_relax_delete_bytes
  48   PARAMS ((bfd *, asection *, bfd_vma, int));
  49 static bfd_boolean sh_elf_align_loads
  50   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *));
  51 static bfd_boolean sh_elf_swap_insns
  52   PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
  53 static bfd_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 *, bfd_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 bfd_boolean sh_elf_mkobject
  65   PARAMS ((bfd *));
  66 static bfd_boolean sh_elf_object_p
  67   PARAMS ((bfd *));
  68 static bfd_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 bfd_boolean sh_elf_adjust_dynamic_symbol
  76   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  77 static bfd_boolean sh_elf_size_dynamic_sections
  78   PARAMS ((bfd *, struct bfd_link_info *));
  79 static bfd_boolean sh_elf_finish_dynamic_symbol
  80   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  81            Elf_Internal_Sym *));
  82 static bfd_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 bfd_boolean create_got_section
  88   PARAMS ((bfd *, struct bfd_link_info *));
  89 static bfd_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 bfd_boolean sh_elf_gc_sweep_hook
  97   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  98            const Elf_Internal_Rela *));
  99 static bfd_boolean allocate_dynrelocs
 100   PARAMS ((struct elf_link_hash_entry *, PTR));
 101 static bfd_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 bfd_boolean elf32_shlin_grok_prstatus
 109   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
 110 static bfd_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 bfd_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      bfd_boolean *again;
2023 {
2024   Elf_Internal_Shdr *symtab_hdr;
2025   Elf_Internal_Rela *internal_relocs;
2026   bfd_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       bfd_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 bfd_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       bfd_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 bfd_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      bfd_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 bfd_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           bfd_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   /* If TRUE, R_SH_TLS_TPOFF32 relocation is generated.  */
3505   bfd_boolean tls_tpoff32;
3506 };
3507
3508 /* sh ELF linker hash entry.  */
3509
3510 struct elf_sh_link_hash_entry
3511 {
3512   struct elf_link_hash_entry root;
3513
3514 #ifdef INCLUDE_SHMEDIA
3515   union
3516   {
3517     bfd_signed_vma refcount;
3518     bfd_vma offset;
3519   } datalabel_got;
3520 #endif
3521
3522   /* Track dynamic relocs copied for this symbol.  */
3523   struct elf_sh_dyn_relocs *dyn_relocs;
3524
3525   bfd_signed_vma gotplt_refcount;
3526
3527   enum {
3528     GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE
3529   } tls_type;
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 bfd_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     (bfd_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     }
3634
3635   return (struct bfd_hash_entry *) ret;
3636 }
3637
3638 /* Create an sh ELF linker hash table.  */
3639
3640 static struct bfd_link_hash_table *
3641 sh_elf_link_hash_table_create (abfd)
3642      bfd *abfd;
3643 {
3644   struct elf_sh_link_hash_table *ret;
3645   bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
3646
3647   ret = (struct elf_sh_link_hash_table *) bfd_malloc (amt);
3648   if (ret == (struct elf_sh_link_hash_table *) NULL)
3649     return NULL;
3650
3651   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
3652                                        sh_elf_link_hash_newfunc))
3653     {
3654       free (ret);
3655       return NULL;
3656     }
3657
3658   ret->sgot = NULL;
3659   ret->sgotplt = NULL;
3660   ret->srelgot = NULL;
3661   ret->splt = NULL;
3662   ret->srelplt = NULL;
3663   ret->sdynbss = NULL;
3664   ret->srelbss = NULL;
3665   ret->sym_sec.abfd = NULL;
3666   ret->tls_ldm_got.refcount = 0;
3667
3668   return &ret->root.root;
3669 }
3670
3671 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3672    shortcuts to them in our hash table.  */
3673
3674 static bfd_boolean
3675 create_got_section (dynobj, info)
3676      bfd *dynobj;
3677      struct bfd_link_info *info;
3678 {
3679   struct elf_sh_link_hash_table *htab;
3680
3681   if (! _bfd_elf_create_got_section (dynobj, info))
3682     return FALSE;
3683
3684   htab = sh_elf_hash_table (info);
3685   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
3686   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3687   if (! htab->sgot || ! htab->sgotplt)
3688     abort ();
3689
3690   htab->srelgot = bfd_make_section (dynobj, ".rela.got");
3691   if (htab->srelgot == NULL
3692       || ! bfd_set_section_flags (dynobj, htab->srelgot,
3693                                   (SEC_ALLOC
3694                                    | SEC_LOAD
3695                                    | SEC_HAS_CONTENTS
3696                                    | SEC_IN_MEMORY
3697                                    | SEC_LINKER_CREATED
3698                                    | SEC_READONLY))
3699       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
3700     return FALSE;
3701   return TRUE;
3702 }
3703
3704 /* Create dynamic sections when linking against a dynamic object.  */
3705
3706 static bfd_boolean
3707 sh_elf_create_dynamic_sections (abfd, info)
3708      bfd *abfd;
3709      struct bfd_link_info *info;
3710 {
3711   struct elf_sh_link_hash_table *htab;
3712   flagword flags, pltflags;
3713   register asection *s;
3714   struct elf_backend_data *bed = get_elf_backend_data (abfd);
3715   int ptralign = 0;
3716
3717   switch (bed->s->arch_size)
3718     {
3719     case 32:
3720       ptralign = 2;
3721       break;
3722
3723     case 64:
3724       ptralign = 3;
3725       break;
3726
3727     default:
3728       bfd_set_error (bfd_error_bad_value);
3729       return FALSE;
3730     }
3731
3732   htab = sh_elf_hash_table (info);
3733
3734   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3735      .rel[a].bss sections.  */
3736
3737   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3738            | SEC_LINKER_CREATED);
3739
3740   pltflags = flags;
3741   pltflags |= SEC_CODE;
3742   if (bed->plt_not_loaded)
3743     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3744   if (bed->plt_readonly)
3745     pltflags |= SEC_READONLY;
3746
3747   s = bfd_make_section (abfd, ".plt");
3748   htab->splt = s;
3749   if (s == NULL
3750       || ! bfd_set_section_flags (abfd, s, pltflags)
3751       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3752     return FALSE;
3753
3754   if (bed->want_plt_sym)
3755     {
3756       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3757          .plt section.  */
3758       struct elf_link_hash_entry *h;
3759       struct bfd_link_hash_entry *bh = NULL;
3760
3761       if (! (_bfd_generic_link_add_one_symbol
3762              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3763               (bfd_vma) 0, (const char *) NULL, FALSE,
3764               get_elf_backend_data (abfd)->collect, &bh)))
3765         return FALSE;
3766
3767       h = (struct elf_link_hash_entry *) bh;
3768       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3769       h->type = STT_OBJECT;
3770
3771       if (info->shared
3772           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
3773         return FALSE;
3774     }
3775
3776   s = bfd_make_section (abfd,
3777                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3778   htab->srelplt = s;
3779   if (s == NULL
3780       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3781       || ! bfd_set_section_alignment (abfd, s, ptralign))
3782     return FALSE;
3783
3784   if (! create_got_section (abfd, info))
3785     return FALSE;
3786
3787   {
3788     const char *secname;
3789     char *relname;
3790     flagword secflags;
3791     asection *sec;
3792
3793     for (sec = abfd->sections; sec; sec = sec->next)
3794       {
3795         secflags = bfd_get_section_flags (abfd, sec);
3796         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3797             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3798           continue;
3799         secname = bfd_get_section_name (abfd, sec);
3800         relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3801         strcpy (relname, ".rela");
3802         strcat (relname, secname);
3803         s = bfd_make_section (abfd, relname);
3804         if (s == NULL
3805             || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3806             || ! bfd_set_section_alignment (abfd, s, ptralign))
3807           return FALSE;
3808       }
3809   }
3810
3811   if (bed->want_dynbss)
3812     {
3813       /* The .dynbss section is a place to put symbols which are defined
3814          by dynamic objects, are referenced by regular objects, and are
3815          not functions.  We must allocate space for them in the process
3816          image and use a R_*_COPY reloc to tell the dynamic linker to
3817          initialize them at run time.  The linker script puts the .dynbss
3818          section into the .bss section of the final image.  */
3819       s = bfd_make_section (abfd, ".dynbss");
3820       htab->sdynbss = s;
3821       if (s == NULL
3822           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
3823         return FALSE;
3824
3825       /* The .rel[a].bss section holds copy relocs.  This section is not
3826          normally needed.  We need to create it here, though, so that the
3827          linker will map it to an output section.  We can't just create it
3828          only if we need it, because we will not know whether we need it
3829          until we have seen all the input files, and the first time the
3830          main linker code calls BFD after examining all the input files
3831          (size_dynamic_sections) the input sections have already been
3832          mapped to the output sections.  If the section turns out not to
3833          be needed, we can discard it later.  We will never need this
3834          section when generating a shared object, since they do not use
3835          copy relocs.  */
3836       if (! info->shared)
3837         {
3838           s = bfd_make_section (abfd,
3839                                 (bed->default_use_rela_p
3840                                  ? ".rela.bss" : ".rel.bss"));
3841           htab->srelbss = s;
3842           if (s == NULL
3843               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3844               || ! bfd_set_section_alignment (abfd, s, ptralign))
3845             return FALSE;
3846         }
3847     }
3848
3849   return TRUE;
3850 }
3851 \f
3852 /* Adjust a symbol defined by a dynamic object and referenced by a
3853    regular object.  The current definition is in some section of the
3854    dynamic object, but we're not including those sections.  We have to
3855    change the definition to something the rest of the link can
3856    understand.  */
3857
3858 static bfd_boolean
3859 sh_elf_adjust_dynamic_symbol (info, h)
3860      struct bfd_link_info *info;
3861      struct elf_link_hash_entry *h;
3862 {
3863   struct elf_sh_link_hash_table *htab;
3864   struct elf_sh_link_hash_entry *eh;
3865   struct elf_sh_dyn_relocs *p;
3866   bfd *dynobj;
3867   asection *s;
3868   unsigned int power_of_two;
3869
3870   dynobj = elf_hash_table (info)->dynobj;
3871
3872   /* Make sure we know what is going on here.  */
3873   BFD_ASSERT (dynobj != NULL
3874               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
3875                   || h->weakdef != NULL
3876                   || ((h->elf_link_hash_flags
3877                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3878                       && (h->elf_link_hash_flags
3879                           & ELF_LINK_HASH_REF_REGULAR) != 0
3880                       && (h->elf_link_hash_flags
3881                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
3882
3883   /* If this is a function, put it in the procedure linkage table.  We
3884      will fill in the contents of the procedure linkage table later,
3885      when we know the address of the .got section.  */
3886   if (h->type == STT_FUNC
3887       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
3888     {
3889       if (h->plt.refcount <= 0
3890           || (! info->shared
3891               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3892               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
3893               && h->root.type != bfd_link_hash_undefweak
3894               && h->root.type != bfd_link_hash_undefined))
3895         {
3896           /* This case can occur if we saw a PLT reloc in an input
3897              file, but the symbol was never referred to by a dynamic
3898              object.  In such a case, we don't actually need to build
3899              a procedure linkage table, and we can just do a REL32
3900              reloc instead.  */
3901           h->plt.offset = (bfd_vma) -1;
3902           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3903         }
3904
3905       return TRUE;
3906     }
3907   else
3908     h->plt.offset = (bfd_vma) -1;
3909
3910   /* If this is a weak symbol, and there is a real definition, the
3911      processor independent code will have arranged for us to see the
3912      real definition first, and we can just use the same value.  */
3913   if (h->weakdef != NULL)
3914     {
3915       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3916                   || h->weakdef->root.type == bfd_link_hash_defweak);
3917       h->root.u.def.section = h->weakdef->root.u.def.section;
3918       h->root.u.def.value = h->weakdef->root.u.def.value;
3919       return TRUE;
3920     }
3921
3922   /* This is a reference to a symbol defined by a dynamic object which
3923      is not a function.  */
3924
3925   /* If we are creating a shared library, we must presume that the
3926      only references to the symbol are via the global offset table.
3927      For such cases we need not do anything here; the relocations will
3928      be handled correctly by relocate_section.  */
3929   if (info->shared)
3930     return TRUE;
3931
3932   /* If there are no references to this symbol that do not use the
3933      GOT, we don't need to generate a copy reloc.  */
3934   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
3935     return TRUE;
3936
3937   /* If -z nocopyreloc was given, we won't generate them either.  */
3938   if (info->nocopyreloc)
3939     {
3940       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
3941       return TRUE;
3942     }
3943
3944   eh = (struct elf_sh_link_hash_entry *) h;
3945   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3946     {
3947       s = p->sec->output_section;
3948       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3949         break;
3950     }
3951
3952   /* If we didn't find any dynamic relocs in sections which needs the
3953      copy reloc, then we'll be keeping the dynamic relocs and avoiding
3954      the copy reloc.  */
3955   if (p == NULL)
3956     {
3957       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
3958       return TRUE;
3959     }
3960
3961   /* We must allocate the symbol in our .dynbss section, which will
3962      become part of the .bss section of the executable.  There will be
3963      an entry for this symbol in the .dynsym section.  The dynamic
3964      object will contain position independent code, so all references
3965      from the dynamic object to this symbol will go through the global
3966      offset table.  The dynamic linker will use the .dynsym entry to
3967      determine the address it must put in the global offset table, so
3968      both the dynamic object and the regular object will refer to the
3969      same memory location for the variable.  */
3970
3971   htab = sh_elf_hash_table (info);
3972   s = htab->sdynbss;
3973   BFD_ASSERT (s != NULL);
3974
3975   /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
3976      copy the initial value out of the dynamic object and into the
3977      runtime process image.  We need to remember the offset into the
3978      .rela.bss section we are going to use.  */
3979   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3980     {
3981       asection *srel;
3982
3983       srel = htab->srelbss;
3984       BFD_ASSERT (srel != NULL);
3985       srel->_raw_size += sizeof (Elf32_External_Rela);
3986       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3987     }
3988
3989   /* We need to figure out the alignment required for this symbol.  I
3990      have no idea how ELF linkers handle this.  */
3991   power_of_two = bfd_log2 (h->size);
3992   if (power_of_two > 3)
3993     power_of_two = 3;
3994
3995   /* Apply the required alignment.  */
3996   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
3997   if (power_of_two > bfd_get_section_alignment (dynobj, s))
3998     {
3999       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
4000         return FALSE;
4001     }
4002
4003   /* Define the symbol as being at this point in the section.  */
4004   h->root.u.def.section = s;
4005   h->root.u.def.value = s->_raw_size;
4006
4007   /* Increment the section size to make room for the symbol.  */
4008   s->_raw_size += h->size;
4009
4010   return TRUE;
4011 }
4012
4013 /* This is the condition under which sh_elf_finish_dynamic_symbol
4014    will be called from elflink.h.  If elflink.h doesn't call our
4015    finish_dynamic_symbol routine, we'll need to do something about
4016    initializing any .plt and .got entries in sh_elf_relocate_section.  */
4017 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
4018   ((DYN)                                                                \
4019    && ((INFO)->shared                                                   \
4020        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
4021    && ((H)->dynindx != -1                                               \
4022        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
4023
4024 /* Allocate space in .plt, .got and associated reloc sections for
4025    dynamic relocs.  */
4026
4027 static bfd_boolean
4028 allocate_dynrelocs (h, inf)
4029      struct elf_link_hash_entry *h;
4030      PTR inf;
4031 {
4032   struct bfd_link_info *info;
4033   struct elf_sh_link_hash_table *htab;
4034   struct elf_sh_link_hash_entry *eh;
4035   struct elf_sh_dyn_relocs *p;
4036
4037   if (h->root.type == bfd_link_hash_indirect)
4038     return TRUE;
4039
4040   if (h->root.type == bfd_link_hash_warning)
4041     /* When warning symbols are created, they **replace** the "real"
4042        entry in the hash table, thus we never get to see the real
4043        symbol in a hash traversal.  So look at it now.  */
4044     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4045
4046   info = (struct bfd_link_info *) inf;
4047   htab = sh_elf_hash_table (info);
4048
4049   eh = (struct elf_sh_link_hash_entry *) h;
4050   if ((h->got.refcount > 0
4051       || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
4052       && eh->gotplt_refcount > 0)
4053     {
4054       /* The symbol has been forced local, or we have some direct got refs,
4055          so treat all the gotplt refs as got refs. */
4056       h->got.refcount += eh->gotplt_refcount;
4057       if (h->plt.refcount >= eh->gotplt_refcount)
4058         h->plt.refcount -= eh->gotplt_refcount;
4059     }
4060
4061   if (htab->root.dynamic_sections_created
4062       && h->plt.refcount > 0)
4063     {
4064       /* Make sure this symbol is output as a dynamic symbol.
4065          Undefined weak syms won't yet be marked as dynamic.  */
4066       if (h->dynindx == -1
4067           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4068         {
4069           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4070             return FALSE;
4071         }
4072
4073       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
4074         {
4075           asection *s = htab->splt;
4076
4077           /* If this is the first .plt entry, make room for the special
4078              first entry.  */
4079           if (s->_raw_size == 0)
4080             s->_raw_size += PLT_ENTRY_SIZE;
4081
4082           h->plt.offset = s->_raw_size;
4083
4084           /* If this symbol is not defined in a regular file, and we are
4085              not generating a shared library, then set the symbol to this
4086              location in the .plt.  This is required to make function
4087              pointers compare as equal between the normal executable and
4088              the shared library.  */
4089           if (! info->shared
4090               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4091             {
4092               h->root.u.def.section = s;
4093               h->root.u.def.value = h->plt.offset;
4094             }
4095
4096           /* Make room for this entry.  */
4097           s->_raw_size += PLT_ENTRY_SIZE;
4098
4099           /* We also need to make an entry in the .got.plt section, which
4100              will be placed in the .got section by the linker script.  */
4101           htab->sgotplt->_raw_size += 4;
4102
4103           /* We also need to make an entry in the .rel.plt section.  */
4104           htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
4105         }
4106       else
4107         {
4108           h->plt.offset = (bfd_vma) -1;
4109           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4110         }
4111     }
4112   else
4113     {
4114       h->plt.offset = (bfd_vma) -1;
4115       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4116     }
4117
4118   if (h->got.refcount > 0)
4119     {
4120       asection *s;
4121       bfd_boolean dyn;
4122       int tls_type = sh_elf_hash_entry (h)->tls_type;
4123
4124       /* Make sure this symbol is output as a dynamic symbol.
4125          Undefined weak syms won't yet be marked as dynamic.  */
4126       if (h->dynindx == -1
4127           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4128         {
4129           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4130             return FALSE;
4131         }
4132
4133       s = htab->sgot;
4134       h->got.offset = s->_raw_size;
4135       s->_raw_size += 4;
4136       /* R_SH_TLS_GD needs 2 consecutive GOT slots.  */
4137       if (tls_type == GOT_TLS_GD)
4138         s->_raw_size += 4;
4139       dyn = htab->root.dynamic_sections_created;
4140       /* R_SH_TLS_IE_32 needs one dynamic relocation,
4141          R_SH_TLS_GD needs one if local symbol and two if global.  */
4142       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
4143           || tls_type == GOT_TLS_IE)
4144         htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4145       else if (tls_type == GOT_TLS_GD)
4146         htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
4147       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
4148         htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4149     }
4150   else
4151     h->got.offset = (bfd_vma) -1;
4152
4153 #ifdef INCLUDE_SHMEDIA
4154   if (eh->datalabel_got.refcount > 0)
4155     {
4156       asection *s;
4157       bfd_boolean dyn;
4158
4159       /* Make sure this symbol is output as a dynamic symbol.
4160          Undefined weak syms won't yet be marked as dynamic.  */
4161       if (h->dynindx == -1
4162           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4163         {
4164           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4165             return FALSE;
4166         }
4167
4168       s = htab->sgot;
4169       eh->datalabel_got.offset = s->_raw_size;
4170       s->_raw_size += 4;
4171       dyn = htab->root.dynamic_sections_created;
4172       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
4173         htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4174     }
4175   else
4176     eh->datalabel_got.offset = (bfd_vma) -1;
4177 #endif
4178
4179   if (eh->dyn_relocs == NULL)
4180     return TRUE;
4181
4182   /* In the shared -Bsymbolic case, discard space allocated for
4183      dynamic pc-relative relocs against symbols which turn out to be
4184      defined in regular objects.  For the normal shared case, discard
4185      space for pc-relative relocs that have become local due to symbol
4186      visibility changes.  */
4187
4188   if (info->shared)
4189     {
4190       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
4191           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
4192               || info->symbolic))
4193         {
4194           struct elf_sh_dyn_relocs **pp;
4195
4196           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
4197             {
4198               p->count -= p->pc_count;
4199               p->pc_count = 0;
4200               if (p->count == 0)
4201                 *pp = p->next;
4202               else
4203                 pp = &p->next;
4204             }
4205         }
4206     }
4207   else
4208     {
4209       for (p = eh->dyn_relocs; p; p = p->next)
4210         if (p->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 bfd_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 bfd_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   bfd_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 bfd_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               bfd_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->no_undefined
4789                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4790             relocation = 0;
4791           else
4792             {
4793               if (! ((*info->callbacks->undefined_symbol)
4794                      (info, h->root.root.string, input_bfd,
4795                       input_section, rel->r_offset,
4796                       (!info->shared || info->no_undefined
4797                        || ELF_ST_VISIBILITY (h->other)))))
4798                 return FALSE;
4799               relocation = 0;
4800             }
4801         }
4802
4803       switch ((int) r_type)
4804         {
4805         final_link_relocate:
4806           /* COFF relocs don't use the addend. The addend is used for
4807              R_SH_DIR32 to be compatible with other compilers.  */
4808           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4809                                         contents, rel->r_offset,
4810                                         relocation, addend);
4811           break;
4812
4813         case R_SH_IND12W:
4814           relocation -= 4;
4815           goto final_link_relocate;
4816
4817         case R_SH_DIR8WPN:
4818         case R_SH_DIR8WPZ:
4819         case R_SH_DIR8WPL:
4820           /* If the reloc is against the start of this section, then
4821              the assembler has already taken care of it and the reloc
4822              is here only to assist in relaxing.  If the reloc is not
4823              against the start of this section, then it's against an
4824              external symbol and we must deal with it ourselves.  */
4825           if (input_section->output_section->vma + input_section->output_offset
4826               != relocation)
4827             {
4828               int disp = (relocation
4829                           - input_section->output_section->vma
4830                           - input_section->output_offset
4831                           - rel->r_offset);
4832               int mask = 0;
4833               switch (r_type)
4834                 {
4835                 case R_SH_DIR8WPN:
4836                 case R_SH_DIR8WPZ: mask = 1; break;
4837                 case R_SH_DIR8WPL: mask = 3; break;
4838                 default: mask = 0; break;
4839                 }
4840               if (disp & mask)
4841                 {
4842                   ((*_bfd_error_handler)
4843                    (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
4844                     bfd_archive_filename (input_section->owner),
4845                     (unsigned long) rel->r_offset));
4846                   bfd_set_error (bfd_error_bad_value);
4847                   return FALSE;
4848                 }
4849               relocation -= 4;
4850               goto final_link_relocate;
4851             }
4852           r = bfd_reloc_ok;
4853           break;
4854
4855         default:
4856 #ifdef INCLUDE_SHMEDIA
4857           if (shmedia_prepare_reloc (info, input_bfd, input_section,
4858                                      contents, rel, &relocation))
4859             goto final_link_relocate;
4860 #endif
4861           bfd_set_error (bfd_error_bad_value);
4862           return FALSE;
4863
4864         case R_SH_DIR32:
4865         case R_SH_REL32:
4866           if (info->shared
4867               && r_symndx != 0
4868               && (input_section->flags & SEC_ALLOC) != 0
4869               && (r_type != R_SH_REL32
4870                   || (h != NULL
4871                       && h->dynindx != -1
4872                       && (! info->symbolic
4873                           || (h->elf_link_hash_flags
4874                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
4875             {
4876               Elf_Internal_Rela outrel;
4877               bfd_byte *loc;
4878               bfd_boolean skip, relocate;
4879
4880               /* When generating a shared object, these relocations
4881                  are copied into the output file to be resolved at run
4882                  time.  */
4883
4884               if (sreloc == NULL)
4885                 {
4886                   const char *name;
4887
4888                   name = (bfd_elf_string_from_elf_section
4889                           (input_bfd,
4890                            elf_elfheader (input_bfd)->e_shstrndx,
4891                            elf_section_data (input_section)->rel_hdr.sh_name));
4892                   if (name == NULL)
4893                     return FALSE;
4894
4895                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4896                               && strcmp (bfd_get_section_name (input_bfd,
4897                                                                input_section),
4898                                          name + 5) == 0);
4899
4900                   sreloc = bfd_get_section_by_name (dynobj, name);
4901                   BFD_ASSERT (sreloc != NULL);
4902                 }
4903
4904               skip = FALSE;
4905               relocate = FALSE;
4906
4907               outrel.r_offset =
4908                 _bfd_elf_section_offset (output_bfd, info, input_section,
4909                                          rel->r_offset);
4910               if (outrel.r_offset == (bfd_vma) -1)
4911                 skip = TRUE;
4912               else if (outrel.r_offset == (bfd_vma) -2)
4913                 skip = TRUE, relocate = TRUE;
4914               outrel.r_offset += (input_section->output_section->vma
4915                                   + input_section->output_offset);
4916
4917               if (skip)
4918                 memset (&outrel, 0, sizeof outrel);
4919               else if (r_type == R_SH_REL32)
4920                 {
4921                   BFD_ASSERT (h != NULL && h->dynindx != -1);
4922                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
4923                   outrel.r_addend
4924                     = bfd_get_32 (input_bfd, contents + rel->r_offset);
4925                 }
4926               else
4927                 {
4928                   /* h->dynindx may be -1 if this symbol was marked to
4929                      become local.  */
4930                   if (h == NULL
4931                       || ((info->symbolic || h->dynindx == -1)
4932                           && (h->elf_link_hash_flags
4933                               & ELF_LINK_HASH_DEF_REGULAR) != 0))
4934                     {
4935                       relocate = TRUE;
4936                       outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4937                       outrel.r_addend
4938                         = relocation + bfd_get_32 (input_bfd,
4939                                                    contents + rel->r_offset);
4940                     }
4941                   else
4942                     {
4943                       BFD_ASSERT (h->dynindx != -1);
4944                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
4945                       outrel.r_addend
4946                         = relocation + bfd_get_32 (input_bfd,
4947                                                    contents + rel->r_offset);
4948                     }
4949                 }
4950
4951               loc = sreloc->contents;
4952               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4953               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4954
4955               /* If this reloc is against an external symbol, we do
4956                  not want to fiddle with the addend.  Otherwise, we
4957                  need to include the symbol value so that it becomes
4958                  an addend for the dynamic reloc.  */
4959               if (! relocate)
4960                 continue;
4961             }
4962           goto final_link_relocate;
4963
4964         case R_SH_GOTPLT32:
4965 #ifdef INCLUDE_SHMEDIA
4966         case R_SH_GOTPLT_LOW16:
4967         case R_SH_GOTPLT_MEDLOW16:
4968         case R_SH_GOTPLT_MEDHI16:
4969         case R_SH_GOTPLT_HI16:
4970         case R_SH_GOTPLT10BY4:
4971         case R_SH_GOTPLT10BY8:
4972 #endif
4973           /* Relocation is to the entry for this symbol in the
4974              procedure linkage table.  */
4975
4976           if (h == NULL
4977               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
4978               || ! info->shared
4979               || info->symbolic
4980               || h->dynindx == -1
4981               || h->plt.offset == (bfd_vma) -1
4982               || h->got.offset != (bfd_vma) -1)
4983             goto force_got;
4984
4985           /* Relocation is to the entry for this symbol in the global
4986              offset table extension for the procedure linkage table.  */
4987
4988           BFD_ASSERT (sgotplt != NULL);
4989           relocation = (sgotplt->output_offset
4990                         + ((h->plt.offset / elf_sh_sizeof_plt (info)
4991                             - 1 + 3) * 4));
4992
4993 #ifdef GOT_BIAS
4994           relocation -= GOT_BIAS;
4995 #endif
4996
4997           goto final_link_relocate;
4998
4999         force_got:
5000         case R_SH_GOT32:
5001 #ifdef INCLUDE_SHMEDIA
5002         case R_SH_GOT_LOW16:
5003         case R_SH_GOT_MEDLOW16:
5004         case R_SH_GOT_MEDHI16:
5005         case R_SH_GOT_HI16:
5006         case R_SH_GOT10BY4:
5007         case R_SH_GOT10BY8:
5008 #endif
5009           /* Relocation is to the entry for this symbol in the global
5010              offset table.  */
5011
5012           BFD_ASSERT (sgot != NULL);
5013
5014           if (h != NULL)
5015             {
5016               bfd_boolean dyn;
5017
5018               off = h->got.offset;
5019 #ifdef INCLUDE_SHMEDIA
5020               if (seen_stt_datalabel)
5021                 {
5022                   struct elf_sh_link_hash_entry *hsh;
5023
5024                   hsh = (struct elf_sh_link_hash_entry *)h;
5025                   off = hsh->datalabel_got.offset;
5026                 }
5027 #endif
5028               BFD_ASSERT (off != (bfd_vma) -1);
5029
5030               dyn = htab->root.dynamic_sections_created;
5031               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
5032                   || (info->shared
5033                       && (info->symbolic || h->dynindx == -1
5034                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
5035                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5036                 {
5037                   /* This is actually a static link, or it is a
5038                      -Bsymbolic link and the symbol is defined
5039                      locally, or the symbol was forced to be local
5040                      because of a version file.  We must initialize
5041                      this entry in the global offset table.  Since the
5042                      offset must always be a multiple of 4, we use the
5043                      least significant bit to record whether we have
5044                      initialized it already.
5045
5046                      When doing a dynamic link, we create a .rela.got
5047                      relocation entry to initialize the value.  This
5048                      is done in the finish_dynamic_symbol routine.  */
5049                   if ((off & 1) != 0)
5050                     off &= ~1;
5051                   else
5052                     {
5053                       bfd_put_32 (output_bfd, relocation,
5054                                   sgot->contents + off);
5055 #ifdef INCLUDE_SHMEDIA
5056                       if (seen_stt_datalabel)
5057                         {
5058                           struct elf_sh_link_hash_entry *hsh;
5059
5060                           hsh = (struct elf_sh_link_hash_entry *)h;
5061                           hsh->datalabel_got.offset |= 1;
5062                         }
5063                       else
5064 #endif
5065                         h->got.offset |= 1;
5066                     }
5067                 }
5068
5069               relocation = sgot->output_offset + off;
5070             }
5071           else
5072             {
5073 #ifdef INCLUDE_SHMEDIA
5074               if (rel->r_addend)
5075                 {
5076                   BFD_ASSERT (local_got_offsets != NULL
5077                               && (local_got_offsets[symtab_hdr->sh_info
5078                                                     + r_symndx]
5079                                   != (bfd_vma) -1));
5080
5081                   off = local_got_offsets[symtab_hdr->sh_info
5082                                           + r_symndx];
5083                 }
5084               else
5085                 {
5086 #endif
5087               BFD_ASSERT (local_got_offsets != NULL
5088                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
5089
5090               off = local_got_offsets[r_symndx];
5091 #ifdef INCLUDE_SHMEDIA
5092                 }
5093 #endif
5094
5095               /* The offset must always be a multiple of 4.  We use
5096                  the least significant bit to record whether we have
5097                  already generated the necessary reloc.  */
5098               if ((off & 1) != 0)
5099                 off &= ~1;
5100               else
5101                 {
5102                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5103
5104                   if (info->shared)
5105                     {
5106                       Elf_Internal_Rela outrel;
5107                       bfd_byte *loc;
5108
5109                       if (srelgot == NULL)
5110                         {
5111                           srelgot = bfd_get_section_by_name (dynobj,
5112                                                              ".rela.got");
5113                           BFD_ASSERT (srelgot != NULL);
5114                         }
5115
5116                       outrel.r_offset = (sgot->output_section->vma
5117                                          + sgot->output_offset
5118                                          + off);
5119                       outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
5120                       outrel.r_addend = relocation;
5121                       loc = srelgot->contents;
5122                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5123                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5124                     }
5125
5126 #ifdef INCLUDE_SHMEDIA
5127                   if (rel->r_addend)
5128                     local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
5129                   else
5130 #endif
5131                     local_got_offsets[r_symndx] |= 1;
5132                 }
5133
5134               relocation = sgot->output_offset + off;
5135             }
5136
5137 #ifdef GOT_BIAS
5138           relocation -= GOT_BIAS;
5139 #endif
5140
5141           goto final_link_relocate;
5142
5143         case R_SH_GOTOFF:
5144 #ifdef INCLUDE_SHMEDIA
5145         case R_SH_GOTOFF_LOW16:
5146         case R_SH_GOTOFF_MEDLOW16:
5147         case R_SH_GOTOFF_MEDHI16:
5148         case R_SH_GOTOFF_HI16:
5149 #endif
5150           /* Relocation is relative to the start of the global offset
5151              table.  */
5152
5153           BFD_ASSERT (sgot != NULL);
5154
5155           /* Note that sgot->output_offset is not involved in this
5156              calculation.  We always want the start of .got.  If we
5157              defined _GLOBAL_OFFSET_TABLE in a different way, as is
5158              permitted by the ABI, we might have to change this
5159              calculation.  */
5160           relocation -= sgot->output_section->vma;
5161
5162 #ifdef GOT_BIAS
5163           relocation -= GOT_BIAS;
5164 #endif
5165
5166           addend = rel->r_addend;
5167
5168           goto final_link_relocate;
5169
5170         case R_SH_GOTPC:
5171 #ifdef INCLUDE_SHMEDIA
5172         case R_SH_GOTPC_LOW16:
5173         case R_SH_GOTPC_MEDLOW16:
5174         case R_SH_GOTPC_MEDHI16:
5175         case R_SH_GOTPC_HI16:
5176 #endif
5177           /* Use global offset table as symbol value.  */
5178
5179           BFD_ASSERT (sgot != NULL);
5180           relocation = sgot->output_section->vma;
5181
5182 #ifdef GOT_BIAS
5183           relocation += GOT_BIAS;
5184 #endif
5185
5186           addend = rel->r_addend;
5187
5188           goto final_link_relocate;
5189
5190         case R_SH_PLT32:
5191 #ifdef INCLUDE_SHMEDIA
5192         case R_SH_PLT_LOW16:
5193         case R_SH_PLT_MEDLOW16:
5194         case R_SH_PLT_MEDHI16:
5195         case R_SH_PLT_HI16:
5196 #endif
5197           /* Relocation is to the entry for this symbol in the
5198              procedure linkage table.  */
5199
5200           /* Resolve a PLT reloc against a local symbol directly,
5201              without using the procedure linkage table.  */
5202           if (h == NULL)
5203             goto final_link_relocate;
5204
5205           if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
5206             goto final_link_relocate;
5207
5208           if (h->plt.offset == (bfd_vma) -1)
5209             {
5210               /* We didn't make a PLT entry for this symbol.  This
5211                  happens when statically linking PIC code, or when
5212                  using -Bsymbolic.  */
5213               goto final_link_relocate;
5214             }
5215
5216           BFD_ASSERT (splt != NULL);
5217           relocation = (splt->output_section->vma
5218                         + splt->output_offset
5219                         + h->plt.offset);
5220
5221 #ifdef INCLUDE_SHMEDIA
5222           relocation++;
5223 #endif
5224
5225           addend = rel->r_addend;
5226
5227           goto final_link_relocate;
5228
5229         case R_SH_LOOP_START:
5230           {
5231             static bfd_vma start, end;
5232
5233             start = (relocation + rel->r_addend
5234                      - (sec->output_section->vma + sec->output_offset));
5235             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5236                                    rel->r_offset, sec, start, end);
5237             break;
5238
5239         case R_SH_LOOP_END:
5240             end = (relocation + rel->r_addend
5241                    - (sec->output_section->vma + sec->output_offset));
5242             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5243                                    rel->r_offset, sec, start, end);
5244             break;
5245           }
5246
5247         case R_SH_TLS_GD_32:
5248         case R_SH_TLS_IE_32:
5249           r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5250           tls_type = GOT_UNKNOWN;
5251           if (h == NULL && local_got_offsets)
5252             tls_type = sh_elf_local_got_tls_type (input_bfd) [r_symndx];
5253           else if (h != NULL)
5254             {
5255               tls_type = sh_elf_hash_entry (h)->tls_type;
5256               if (! info->shared
5257                   && (h->dynindx == -1
5258                       || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5259                 {
5260                   struct elf_sh_dyn_relocs *p;
5261
5262                   /* If TPOFF32 relocation can be created, convert it.  */
5263                   for (p = sh_elf_hash_entry (h)->dyn_relocs; p; p = p->next)
5264                     if (p->sec == input_section && p->tls_tpoff32)
5265                       {
5266                         r_type = R_SH_TLS_LE_32;
5267                         break;
5268                       }
5269                 }
5270             }
5271
5272           if (r_type == R_SH_TLS_GD_32 && tls_type == GOT_TLS_IE)
5273             r_type = R_SH_TLS_IE_32;
5274
5275           if (r_type == R_SH_TLS_LE_32)
5276             {
5277               bfd_vma offset;
5278               unsigned short insn;
5279               int indx;
5280               Elf_Internal_Rela outrel;
5281               bfd_byte *loc;
5282
5283               if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
5284                 {
5285                   /* GD->LE transition:
5286                        mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5287                        jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5288                        1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5289                      We change it into:
5290                        mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5291                        nop; nop; ...
5292                        1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:.  */
5293
5294                   offset = rel->r_offset;
5295                   BFD_ASSERT (offset >= 16);
5296                   /* Size of GD instructions is 16 or 18.  */
5297                   offset -= 16;
5298                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5299                   if ((insn & 0xff00) == 0xc700)
5300                     {
5301                       BFD_ASSERT (offset >= 2);
5302                       offset -= 2;
5303                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
5304                     }
5305
5306                   BFD_ASSERT ((insn & 0xff00) == 0xd400);
5307                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
5308                   BFD_ASSERT ((insn & 0xff00) == 0xc700);
5309                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
5310                   BFD_ASSERT ((insn & 0xff00) == 0xd100);
5311                   insn = bfd_get_16 (input_bfd, contents + offset + 6);
5312                   BFD_ASSERT (insn == 0x310c);
5313                   insn = bfd_get_16 (input_bfd, contents + offset + 8);
5314                   BFD_ASSERT (insn == 0x410b);
5315                   insn = bfd_get_16 (input_bfd, contents + offset + 10);
5316                   BFD_ASSERT (insn == 0x34cc);
5317
5318                   bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
5319                   bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
5320                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5321                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5322                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5323                 }
5324               else
5325                 {
5326                   int index;
5327
5328                   /* IE->LE transition:
5329                      mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5330                      bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5331                      We change it into:
5332                      mov.l .Ln,rM; stc gbr,rN; nop; ...;
5333                      1: x@TPOFF; 2:.  */
5334
5335                   offset = rel->r_offset;
5336                   BFD_ASSERT (offset >= 16);
5337                   /* Size of IE instructions is 10 or 12.  */
5338                   offset -= 10;
5339                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5340                   if ((insn & 0xf0ff) == 0x0012)
5341                     {
5342                       BFD_ASSERT (offset >= 2);
5343                       offset -= 2;
5344                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
5345                     }
5346
5347                   BFD_ASSERT ((insn & 0xff00) == 0xd000);
5348                   index = insn & 0x00ff;
5349                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
5350                   BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
5351                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
5352                   BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
5353                   insn = 0xd000 | (insn & 0x0f00) | index;
5354                   bfd_put_16 (output_bfd, insn, contents + offset + 0);
5355                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5356                 }
5357
5358               if (sreloc == NULL)
5359                 {
5360                   const char *name;
5361
5362                   name = (bfd_elf_string_from_elf_section
5363                           (input_bfd,
5364                            elf_elfheader (input_bfd)->e_shstrndx,
5365                            elf_section_data (input_section)->rel_hdr.sh_name));
5366                   if (name == NULL)
5367                     return FALSE;
5368
5369                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5370                               && strcmp (bfd_get_section_name (input_bfd,
5371                                                                input_section),
5372                                          name + 5) == 0);
5373
5374                   sreloc = bfd_get_section_by_name (dynobj, name);
5375                   BFD_ASSERT (sreloc != NULL);
5376                 }
5377
5378               if (h == NULL
5379                   || h->dynindx == -1
5380                   || (! info->shared
5381                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5382                 indx = 0;
5383               else
5384                 indx = h->dynindx;
5385               outrel.r_offset = (input_section->output_section->vma
5386                                  + input_section->output_offset
5387                                  + rel->r_offset);
5388               outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5389               if (indx == 0)
5390                 outrel.r_addend = relocation - dtpoff_base (info);
5391               else
5392                 outrel.r_addend = 0;
5393
5394               loc = sreloc->contents;
5395               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5396               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5397               continue;
5398             }
5399
5400           sgot = htab->sgot;
5401           if (sgot == NULL)
5402             abort ();
5403
5404           if (h != NULL)
5405             off = h->got.offset;
5406           else
5407             {
5408               if (local_got_offsets == NULL)
5409                 abort ();
5410
5411               off = local_got_offsets[r_symndx];
5412             }
5413
5414           if ((off & 1) != 0)
5415             off &= ~1;
5416           else
5417             {
5418               Elf_Internal_Rela outrel;
5419               bfd_byte *loc;
5420               int dr_type, indx;
5421
5422               if (srelgot == NULL)
5423                 {
5424                   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5425                   BFD_ASSERT (srelgot != NULL);
5426                 }
5427
5428               outrel.r_offset = (sgot->output_section->vma
5429                                  + sgot->output_offset + off);
5430
5431               if (h == NULL
5432                   || h->dynindx == -1
5433                   || (! info->shared
5434                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5435                 indx = 0;
5436               else
5437                 indx = h->dynindx;
5438               dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
5439                          R_SH_TLS_TPOFF32);
5440               if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
5441                 outrel.r_addend = relocation - dtpoff_base (info);
5442               else
5443                 outrel.r_addend = 0;
5444               outrel.r_info = ELF32_R_INFO (indx, dr_type);
5445               loc = srelgot->contents;
5446               loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5447               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5448
5449               if (r_type == R_SH_TLS_GD_32)
5450                 {
5451                   if (indx == 0)
5452                     {
5453                       bfd_put_32 (output_bfd,
5454                                   relocation - dtpoff_base (info),
5455                                   sgot->contents + off + 4);
5456                     }
5457                   else
5458                     {
5459                       outrel.r_info = ELF32_R_INFO (indx,
5460                                                     R_SH_TLS_DTPOFF32);
5461                       outrel.r_offset += 4;
5462                       outrel.r_addend = 0;
5463                       srelgot->reloc_count++;
5464                       loc += sizeof (Elf32_External_Rela);
5465                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5466                     }
5467                 }
5468
5469               if (h != NULL)
5470                 h->got.offset |= 1;
5471               else
5472                 local_got_offsets[r_symndx] |= 1;
5473             }
5474
5475           if (off >= (bfd_vma) -2)
5476             abort ();
5477
5478           if (r_type == (int) ELF32_R_TYPE (rel->r_info))
5479             relocation = sgot->output_offset + off;
5480           else
5481             {
5482               bfd_vma offset;
5483               unsigned short insn;
5484
5485               /* GD->IE transition:
5486                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5487                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5488                    1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5489                  We change it into:
5490                    mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5491                    nop; nop; bra 3f; nop; .align 2;
5492                    1: .long x@TPOFF; 2:...; 3:.  */
5493
5494               offset = rel->r_offset;
5495               BFD_ASSERT (offset >= 16);
5496               /* Size of GD instructions is 16 or 18.  */
5497               offset -= 16;
5498               insn = bfd_get_16 (input_bfd, contents + offset + 0);
5499               if ((insn & 0xff00) == 0xc700)
5500                 {
5501                   BFD_ASSERT (offset >= 2);
5502                   offset -= 2;
5503                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5504                 }
5505
5506               BFD_ASSERT ((insn & 0xff00) == 0xd400);
5507
5508               /* Replace mov.l 1f,R4 with mov.l 1f,r0.  */
5509               bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
5510
5511               insn = bfd_get_16 (input_bfd, contents + offset + 2);
5512               BFD_ASSERT ((insn & 0xff00) == 0xc700);
5513               insn = bfd_get_16 (input_bfd, contents + offset + 4);
5514               BFD_ASSERT ((insn & 0xff00) == 0xd100);
5515               insn = bfd_get_16 (input_bfd, contents + offset + 6);
5516               BFD_ASSERT (insn == 0x310c);
5517               insn = bfd_get_16 (input_bfd, contents + offset + 8);
5518               BFD_ASSERT (insn == 0x410b);
5519               insn = bfd_get_16 (input_bfd, contents + offset + 10);
5520               BFD_ASSERT (insn == 0x34cc);
5521
5522               bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
5523               bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
5524               bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
5525               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5526               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5527
5528               bfd_put_32 (output_bfd, sgot->output_offset + off,
5529                           contents + rel->r_offset);
5530
5531               continue;
5532           }
5533
5534           addend = rel->r_addend;
5535
5536           goto final_link_relocate;
5537
5538         case R_SH_TLS_LD_32:
5539           if (! info->shared)
5540             {
5541               bfd_vma offset;
5542               unsigned short insn;
5543
5544               /* LD->LE transition:
5545                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5546                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5547                    1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5548                  We change it into:
5549                    stc gbr,r0; nop; nop; nop;
5550                    nop; nop; bra 3f; ...; 3:.  */
5551
5552               offset = rel->r_offset;
5553               BFD_ASSERT (offset >= 16);
5554               /* Size of LD instructions is 16 or 18.  */
5555               offset -= 16;
5556               insn = bfd_get_16 (input_bfd, contents + offset + 0);
5557               if ((insn & 0xff00) == 0xc700)
5558                 {
5559                   BFD_ASSERT (offset >= 2);
5560                   offset -= 2;
5561                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5562                 }
5563
5564               BFD_ASSERT ((insn & 0xff00) == 0xd400);
5565               insn = bfd_get_16 (input_bfd, contents + offset + 2);
5566               BFD_ASSERT ((insn & 0xff00) == 0xc700);
5567               insn = bfd_get_16 (input_bfd, contents + offset + 4);
5568               BFD_ASSERT ((insn & 0xff00) == 0xd100);
5569               insn = bfd_get_16 (input_bfd, contents + offset + 6);
5570               BFD_ASSERT (insn == 0x310c);
5571               insn = bfd_get_16 (input_bfd, contents + offset + 8);
5572               BFD_ASSERT (insn == 0x410b);
5573               insn = bfd_get_16 (input_bfd, contents + offset + 10);
5574               BFD_ASSERT (insn == 0x34cc);
5575
5576               bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5577               bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5578               bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5579               bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5580               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5581               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5582
5583               continue;
5584             }
5585
5586           sgot = htab->sgot;
5587           if (sgot == NULL)
5588             abort ();
5589
5590           off = htab->tls_ldm_got.offset;
5591           if (off & 1)
5592             off &= ~1;
5593           else
5594             {
5595               Elf_Internal_Rela outrel;
5596               bfd_byte *loc;
5597
5598               srelgot = htab->srelgot;
5599               if (srelgot == NULL)
5600                 abort ();
5601
5602               outrel.r_offset = (sgot->output_section->vma
5603                                  + sgot->output_offset + off);
5604               outrel.r_addend = 0;
5605               outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
5606               loc = srelgot->contents;
5607               loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5608               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5609               htab->tls_ldm_got.offset |= 1;
5610             }
5611
5612           relocation = sgot->output_offset + off;
5613           addend = rel->r_addend;
5614
5615           goto final_link_relocate;
5616
5617         case R_SH_TLS_LDO_32:
5618           if (! info->shared)
5619             {
5620               int indx;
5621               Elf_Internal_Rela outrel;
5622               bfd_byte *loc;
5623
5624               if (sreloc == NULL)
5625                 {
5626                   const char *name;
5627
5628                   name = (bfd_elf_string_from_elf_section
5629                           (input_bfd,
5630                            elf_elfheader (input_bfd)->e_shstrndx,
5631                            elf_section_data (input_section)->rel_hdr.sh_name));
5632                   if (name == NULL)
5633                     return FALSE;
5634
5635                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5636                               && strcmp (bfd_get_section_name (input_bfd,
5637                                                                input_section),
5638                                          name + 5) == 0);
5639
5640                   sreloc = bfd_get_section_by_name (dynobj, name);
5641                   BFD_ASSERT (sreloc != NULL);
5642                 }
5643
5644               indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5645               outrel.r_offset = (input_section->output_section->vma
5646                                  + input_section->output_offset
5647                                  + rel->r_offset);
5648               outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5649               if (indx == 0)
5650                 outrel.r_addend = relocation - dtpoff_base (info);
5651               else
5652                 outrel.r_addend = 0;
5653
5654               loc = sreloc->contents;
5655               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5656               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5657               continue;
5658             }
5659           else
5660             relocation -= dtpoff_base (info);
5661
5662           addend = rel->r_addend;
5663           goto final_link_relocate;
5664
5665         case R_SH_TLS_LE_32:
5666           {
5667             int indx;
5668             Elf_Internal_Rela outrel;
5669             bfd_byte *loc;
5670
5671             if (sreloc == NULL)
5672               {
5673                 const char *name;
5674
5675                 name = (bfd_elf_string_from_elf_section
5676                         (input_bfd,
5677                          elf_elfheader (input_bfd)->e_shstrndx,
5678                          elf_section_data (input_section)->rel_hdr.sh_name));
5679                 if (name == NULL)
5680                   return FALSE;
5681
5682                 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5683                             && strcmp (bfd_get_section_name (input_bfd,
5684                                                              input_section),
5685                                        name + 5) == 0);
5686
5687                 sreloc = bfd_get_section_by_name (dynobj, name);
5688                 BFD_ASSERT (sreloc != NULL);
5689               }
5690
5691             indx = (h && h->dynindx != -1) ? h->dynindx : 0;
5692             outrel.r_offset = (input_section->output_section->vma
5693                                + input_section->output_offset
5694                                + rel->r_offset);
5695             outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5696             if (indx == 0)
5697               outrel.r_addend = relocation - dtpoff_base (info);
5698             else
5699               outrel.r_addend = 0;
5700
5701             loc = sreloc->contents;
5702             loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5703             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5704             continue;
5705           }
5706         }
5707
5708     relocation_done:
5709       if (r != bfd_reloc_ok)
5710         {
5711           switch (r)
5712             {
5713             default:
5714             case bfd_reloc_outofrange:
5715               abort ();
5716             case bfd_reloc_overflow:
5717               {
5718                 const char *name;
5719
5720                 if (h != NULL)
5721                   name = h->root.root.string;
5722                 else
5723                   {
5724                     name = (bfd_elf_string_from_elf_section
5725                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
5726                     if (name == NULL)
5727                       return FALSE;
5728                     if (*name == '\0')
5729                       name = bfd_section_name (input_bfd, sec);
5730                   }
5731                 if (! ((*info->callbacks->reloc_overflow)
5732                        (info, name, howto->name, (bfd_vma) 0,
5733                         input_bfd, input_section, rel->r_offset)))
5734                   return FALSE;
5735               }
5736               break;
5737             }
5738         }
5739     }
5740
5741   return TRUE;
5742 }
5743
5744 /* This is a version of bfd_generic_get_relocated_section_contents
5745    which uses sh_elf_relocate_section.  */
5746
5747 static bfd_byte *
5748 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
5749                                        data, relocateable, symbols)
5750      bfd *output_bfd;
5751      struct bfd_link_info *link_info;
5752      struct bfd_link_order *link_order;
5753      bfd_byte *data;
5754      bfd_boolean relocateable;
5755      asymbol **symbols;
5756 {
5757   Elf_Internal_Shdr *symtab_hdr;
5758   asection *input_section = link_order->u.indirect.section;
5759   bfd *input_bfd = input_section->owner;
5760   asection **sections = NULL;
5761   Elf_Internal_Rela *internal_relocs = NULL;
5762   Elf_Internal_Sym *isymbuf = NULL;
5763
5764   /* We only need to handle the case of relaxing, or of having a
5765      particular set of section contents, specially.  */
5766   if (relocateable
5767       || elf_section_data (input_section)->this_hdr.contents == NULL)
5768     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5769                                                        link_order, data,
5770                                                        relocateable,
5771                                                        symbols);
5772
5773   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5774
5775   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5776           (size_t) input_section->_raw_size);
5777
5778   if ((input_section->flags & SEC_RELOC) != 0
5779       && input_section->reloc_count > 0)
5780     {
5781       asection **secpp;
5782       Elf_Internal_Sym *isym, *isymend;
5783       bfd_size_type amt;
5784
5785       internal_relocs = (_bfd_elf32_link_read_relocs
5786                          (input_bfd, input_section, (PTR) NULL,
5787                           (Elf_Internal_Rela *) NULL, FALSE));
5788       if (internal_relocs == NULL)
5789         goto error_return;
5790
5791       if (symtab_hdr->sh_info != 0)
5792         {
5793           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5794           if (isymbuf == NULL)
5795             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5796                                             symtab_hdr->sh_info, 0,
5797                                             NULL, NULL, NULL);
5798           if (isymbuf == NULL)
5799             goto error_return;
5800         }
5801
5802       amt = symtab_hdr->sh_info;
5803       amt *= sizeof (asection *);
5804       sections = (asection **) bfd_malloc (amt);
5805       if (sections == NULL && amt != 0)
5806         goto error_return;
5807
5808       isymend = isymbuf + symtab_hdr->sh_info;
5809       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5810         {
5811           asection *isec;
5812
5813           if (isym->st_shndx == SHN_UNDEF)
5814             isec = bfd_und_section_ptr;
5815           else if (isym->st_shndx == SHN_ABS)
5816             isec = bfd_abs_section_ptr;
5817           else if (isym->st_shndx == SHN_COMMON)
5818             isec = bfd_com_section_ptr;
5819           else
5820             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5821
5822           *secpp = isec;
5823         }
5824
5825       if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5826                                      input_section, data, internal_relocs,
5827                                      isymbuf, sections))
5828         goto error_return;
5829
5830       if (sections != NULL)
5831         free (sections);
5832       if (isymbuf != NULL
5833           && symtab_hdr->contents != (unsigned char *) isymbuf)
5834         free (isymbuf);
5835       if (elf_section_data (input_section)->relocs != internal_relocs)
5836         free (internal_relocs);
5837     }
5838
5839   return data;
5840
5841  error_return:
5842   if (sections != NULL)
5843     free (sections);
5844   if (isymbuf != NULL
5845       && symtab_hdr->contents != (unsigned char *) isymbuf)
5846     free (isymbuf);
5847   if (internal_relocs != NULL
5848       && elf_section_data (input_section)->relocs != internal_relocs)
5849     free (internal_relocs);
5850   return NULL;
5851 }
5852
5853 /* Return the base VMA address which should be subtracted from real addresses
5854    when resolving @dtpoff relocation.
5855    This is PT_TLS segment p_vaddr.  */
5856
5857 static bfd_vma
5858 dtpoff_base (info)
5859      struct bfd_link_info *info;
5860 {
5861  /* If tls_segment is NULL, we should have signalled an error already.  */
5862  if (elf_hash_table (info)->tls_segment == NULL)
5863    return 0;
5864   return elf_hash_table (info)->tls_segment->start;
5865 }
5866
5867 static asection *
5868 sh_elf_gc_mark_hook (sec, info, rel, h, sym)
5869      asection *sec;
5870      struct bfd_link_info *info ATTRIBUTE_UNUSED;
5871      Elf_Internal_Rela *rel;
5872      struct elf_link_hash_entry *h;
5873      Elf_Internal_Sym *sym;
5874 {
5875   if (h != NULL)
5876     {
5877       switch (ELF32_R_TYPE (rel->r_info))
5878         {
5879         case R_SH_GNU_VTINHERIT:
5880         case R_SH_GNU_VTENTRY:
5881           break;
5882
5883         default:
5884 #ifdef INCLUDE_SHMEDIA
5885           while (h->root.type == bfd_link_hash_indirect
5886                  && h->root.u.i.link)
5887             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5888 #endif
5889           switch (h->root.type)
5890             {
5891             case bfd_link_hash_defined:
5892             case bfd_link_hash_defweak:
5893               return h->root.u.def.section;
5894
5895             case bfd_link_hash_common:
5896               return h->root.u.c.p->section;
5897
5898             default:
5899               break;
5900             }
5901         }
5902     }
5903   else
5904     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5905
5906   return NULL;
5907 }
5908
5909 /* Update the got entry reference counts for the section being removed.  */
5910
5911 static bfd_boolean
5912 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
5913      bfd *abfd;
5914      struct bfd_link_info *info;
5915      asection *sec;
5916      const Elf_Internal_Rela *relocs;
5917 {
5918   Elf_Internal_Shdr *symtab_hdr;
5919   struct elf_link_hash_entry **sym_hashes;
5920   bfd_signed_vma *local_got_refcounts;
5921   const Elf_Internal_Rela *rel, *relend;
5922
5923   elf_section_data (sec)->local_dynrel = NULL;
5924
5925   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5926   sym_hashes = elf_sym_hashes (abfd);
5927   local_got_refcounts = elf_local_got_refcounts (abfd);
5928
5929   relend = relocs + sec->reloc_count;
5930   for (rel = relocs; rel < relend; rel++)
5931     {
5932       unsigned long r_symndx;
5933       unsigned int r_type;
5934       struct elf_link_hash_entry *h = NULL;
5935 #ifdef INCLUDE_SHMEDIA
5936       int seen_stt_datalabel = 0;
5937 #endif
5938
5939       r_symndx = ELF32_R_SYM (rel->r_info);
5940       if (r_symndx >= symtab_hdr->sh_info)
5941         {
5942           struct elf_sh_link_hash_entry *eh;
5943           struct elf_sh_dyn_relocs **pp;
5944           struct elf_sh_dyn_relocs *p;
5945
5946           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5947 #ifdef INCLUDE_SHMEDIA
5948           while (h->root.type == bfd_link_hash_indirect
5949                  || h->root.type == bfd_link_hash_warning)
5950             {
5951               seen_stt_datalabel |= h->type == STT_DATALABEL;
5952               h = (struct elf_link_hash_entry *) h->root.u.i.link;
5953             }
5954 #endif
5955           eh = (struct elf_sh_link_hash_entry *) h;
5956           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5957             if (p->sec == sec)
5958               {
5959                 /* Everything must go for SEC.  */
5960                 *pp = p->next;
5961                 break;
5962               }
5963         }
5964
5965       r_type = ELF32_R_TYPE (rel->r_info);
5966       switch (sh_elf_optimized_tls_reloc (info, r_type, h != NULL))
5967         {
5968         case R_SH_TLS_LD_32:
5969           if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0)
5970             sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
5971           break;
5972
5973         case R_SH_GOT32:
5974         case R_SH_GOTOFF:
5975         case R_SH_GOTPC:
5976 #ifdef INCLUDE_SHMEDIA
5977         case R_SH_GOT_LOW16:
5978         case R_SH_GOT_MEDLOW16:
5979         case R_SH_GOT_MEDHI16:
5980         case R_SH_GOT_HI16:
5981         case R_SH_GOT10BY4:
5982         case R_SH_GOT10BY8:
5983         case R_SH_GOTOFF_LOW16:
5984         case R_SH_GOTOFF_MEDLOW16:
5985         case R_SH_GOTOFF_MEDHI16:
5986         case R_SH_GOTOFF_HI16:
5987         case R_SH_GOTPC_LOW16:
5988         case R_SH_GOTPC_MEDLOW16:
5989         case R_SH_GOTPC_MEDHI16:
5990         case R_SH_GOTPC_HI16:
5991 #endif
5992         case R_SH_TLS_GD_32:
5993         case R_SH_TLS_IE_32:
5994           if (h != NULL)
5995             {
5996 #ifdef INCLUDE_SHMEDIA
5997               if (seen_stt_datalabel)
5998                 {
5999                   struct elf_sh_link_hash_entry *eh;
6000                   eh = (struct elf_sh_link_hash_entry *) h;
6001                   if (eh->datalabel_got.refcount > 0)
6002                     eh->datalabel_got.refcount -= 1;
6003                 }
6004               else
6005 #endif
6006                 if (h->got.refcount > 0)
6007                   h->got.refcount -= 1;
6008             }
6009           else if (local_got_refcounts != NULL)
6010             {
6011 #ifdef INCLUDE_SHMEDIA
6012               if (rel->r_addend & 1)
6013                 {
6014                   if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
6015                     local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
6016                 }
6017               else
6018 #endif
6019                 if (local_got_refcounts[r_symndx] > 0)
6020                   local_got_refcounts[r_symndx] -= 1;
6021             }
6022           break;
6023
6024         case R_SH_DIR32:
6025         case R_SH_REL32:
6026           if (info->shared)
6027             break;
6028           /* Fall thru */
6029
6030         case R_SH_PLT32:
6031 #ifdef INCLUDE_SHMEDIA
6032         case R_SH_PLT_LOW16:
6033         case R_SH_PLT_MEDLOW16:
6034         case R_SH_PLT_MEDHI16:
6035         case R_SH_PLT_HI16:
6036 #endif
6037           if (h != NULL)
6038             {
6039               if (h->plt.refcount > 0)
6040                 h->plt.refcount -= 1;
6041             }
6042           break;
6043
6044         case R_SH_GOTPLT32:
6045 #ifdef INCLUDE_SHMEDIA
6046         case R_SH_GOTPLT_LOW16:
6047         case R_SH_GOTPLT_MEDLOW16:
6048         case R_SH_GOTPLT_MEDHI16:
6049         case R_SH_GOTPLT_HI16:
6050         case R_SH_GOTPLT10BY4:
6051         case R_SH_GOTPLT10BY8:
6052 #endif
6053           if (h != NULL)
6054             {
6055               struct elf_sh_link_hash_entry *eh;
6056               eh = (struct elf_sh_link_hash_entry *) h;
6057               if (eh->gotplt_refcount > 0)
6058                 {
6059                   eh->gotplt_refcount -= 1;
6060                   if (h->plt.refcount > 0)
6061                     h->plt.refcount -= 1;
6062                 }
6063 #ifdef INCLUDE_SHMEDIA
6064               else if (seen_stt_datalabel)
6065                 {
6066                   if (eh->datalabel_got.refcount > 0)
6067                     eh->datalabel_got.refcount -= 1;
6068                 }
6069 #endif
6070               else if (h->got.refcount > 0)
6071                 h->got.refcount -= 1;
6072             }
6073           else if (local_got_refcounts != NULL)
6074             {
6075 #ifdef INCLUDE_SHMEDIA
6076               if (rel->r_addend & 1)
6077                 {
6078                   if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
6079                     local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
6080                 }
6081               else
6082 #endif
6083                 if (local_got_refcounts[r_symndx] > 0)
6084                   local_got_refcounts[r_symndx] -= 1;
6085             }
6086           break;
6087
6088         default:
6089           break;
6090         }
6091     }
6092
6093   return TRUE;
6094 }
6095
6096 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
6097
6098 static void
6099 sh_elf_copy_indirect_symbol (bed, dir, ind)
6100      struct elf_backend_data *bed;
6101      struct elf_link_hash_entry *dir, *ind;
6102 {
6103   struct elf_sh_link_hash_entry *edir, *eind;
6104 #ifdef INCLUDE_SHMEDIA
6105   bfd_signed_vma tmp;
6106 #endif
6107
6108   edir = (struct elf_sh_link_hash_entry *) dir;
6109   eind = (struct elf_sh_link_hash_entry *) ind;
6110
6111   if (eind->dyn_relocs != NULL)
6112     {
6113       if (edir->dyn_relocs != NULL)
6114         {
6115           struct elf_sh_dyn_relocs **pp;
6116           struct elf_sh_dyn_relocs *p;
6117
6118           BFD_ASSERT (ind->root.type != bfd_link_hash_indirect);
6119
6120           /* Add reloc counts against the weak sym to the strong sym
6121              list.  Merge any entries against the same section.  */
6122           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
6123             {
6124               struct elf_sh_dyn_relocs *q;
6125
6126               for (q = edir->dyn_relocs; q != NULL; q = q->next)
6127                 if (q->sec == p->sec)
6128                   {
6129                     q->pc_count += p->pc_count;
6130                     q->count += p->count;
6131                     *pp = p->next;
6132                     break;
6133                   }
6134               if (q == NULL)
6135                 pp = &p->next;
6136             }
6137           *pp = edir->dyn_relocs;
6138         }
6139
6140       edir->dyn_relocs = eind->dyn_relocs;
6141       eind->dyn_relocs = NULL;
6142     }
6143   edir->gotplt_refcount = eind->gotplt_refcount;
6144   eind->gotplt_refcount = 0;
6145 #ifdef INCLUDE_SHMEDIA
6146   tmp = edir->datalabel_got.refcount;
6147   if (tmp < 1)
6148     {
6149       edir->datalabel_got.refcount = eind->datalabel_got.refcount;
6150       eind->datalabel_got.refcount = tmp;
6151     }
6152   else
6153     BFD_ASSERT (eind->datalabel_got.refcount < 1);
6154 #endif
6155
6156   if (ind->root.type == bfd_link_hash_indirect
6157       && dir->got.refcount <= 0)
6158     {
6159       edir->tls_type = eind->tls_type;
6160       eind->tls_type = GOT_UNKNOWN;
6161     }
6162
6163   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
6164 }
6165
6166 static int
6167 sh_elf_optimized_tls_reloc (info, r_type, is_local)
6168      struct bfd_link_info *info;
6169      int r_type;
6170      int is_local;
6171 {
6172   if (info->shared)
6173     return r_type;
6174
6175   switch (r_type)
6176     {
6177     case R_SH_TLS_GD_32:
6178     case R_SH_TLS_IE_32:
6179       if (is_local)
6180         return R_SH_TLS_LE_32;
6181       return R_SH_TLS_IE_32;
6182     case R_SH_TLS_LD_32:
6183       return R_SH_TLS_LE_32;
6184     }
6185
6186   return r_type;
6187 }
6188
6189 /* Look through the relocs for a section during the first phase.
6190    Since we don't do .gots or .plts, we just need to consider the
6191    virtual table relocs for gc.  */
6192
6193 static bfd_boolean
6194 sh_elf_check_relocs (abfd, info, sec, relocs)
6195      bfd *abfd;
6196      struct bfd_link_info *info;
6197      asection *sec;
6198      const Elf_Internal_Rela *relocs;
6199 {
6200   Elf_Internal_Shdr *symtab_hdr;
6201   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6202   struct elf_sh_link_hash_table *htab;
6203   const Elf_Internal_Rela *rel;
6204   const Elf_Internal_Rela *rel_end;
6205   bfd *dynobj;
6206   bfd_vma *local_got_offsets;
6207   asection *sgot;
6208   asection *srelgot;
6209   asection *sreloc;
6210   unsigned int r_type;
6211   int tls_type, old_tls_type;
6212
6213   sgot = NULL;
6214   srelgot = NULL;
6215   sreloc = NULL;
6216
6217   if (info->relocateable)
6218     return TRUE;
6219
6220   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6221   sym_hashes = elf_sym_hashes (abfd);
6222   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
6223   if (!elf_bad_symtab (abfd))
6224     sym_hashes_end -= symtab_hdr->sh_info;
6225
6226   htab = sh_elf_hash_table (info);
6227   dynobj = htab->root.dynobj;
6228   local_got_offsets = elf_local_got_offsets (abfd);
6229
6230   rel_end = relocs + sec->reloc_count;
6231   for (rel = relocs; rel < rel_end; rel++)
6232     {
6233       struct elf_link_hash_entry *h;
6234       unsigned long r_symndx;
6235 #ifdef INCLUDE_SHMEDIA
6236       int seen_stt_datalabel = 0;
6237 #endif
6238
6239       r_symndx = ELF32_R_SYM (rel->r_info);
6240       r_type = ELF32_R_TYPE (rel->r_info);
6241
6242       if (r_symndx < symtab_hdr->sh_info)
6243         h = NULL;
6244       else
6245         {
6246           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6247 #ifdef INCLUDE_SHMEDIA
6248           while (h->root.type == bfd_link_hash_indirect
6249                  || h->root.type == bfd_link_hash_warning)
6250             {
6251               seen_stt_datalabel |= h->type == STT_DATALABEL;
6252               h = (struct elf_link_hash_entry *) h->root.u.i.link;
6253             }
6254 #endif
6255         }
6256
6257       r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
6258       if (! info->shared
6259           && r_type == R_SH_TLS_IE_32
6260           && h != NULL
6261           && h->root.type != bfd_link_hash_undefined
6262           && h->root.type != bfd_link_hash_undefweak
6263           && (h->dynindx == -1
6264               || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
6265         r_type = R_SH_TLS_LE_32;
6266
6267       /* Some relocs require a global offset table.  */
6268       if (htab->sgot == NULL)
6269         {
6270           switch (r_type)
6271             {
6272             case R_SH_GOTPLT32:
6273             case R_SH_GOT32:
6274             case R_SH_GOTOFF:
6275             case R_SH_GOTPC:
6276 #ifdef INCLUDE_SHMEDIA
6277             case R_SH_GOTPLT_LOW16:
6278             case R_SH_GOTPLT_MEDLOW16:
6279             case R_SH_GOTPLT_MEDHI16:
6280             case R_SH_GOTPLT_HI16:
6281             case R_SH_GOTPLT10BY4:
6282             case R_SH_GOTPLT10BY8:
6283             case R_SH_GOT_LOW16:
6284             case R_SH_GOT_MEDLOW16:
6285             case R_SH_GOT_MEDHI16:
6286             case R_SH_GOT_HI16:
6287             case R_SH_GOT10BY4:
6288             case R_SH_GOT10BY8:
6289             case R_SH_GOTOFF_LOW16:
6290             case R_SH_GOTOFF_MEDLOW16:
6291             case R_SH_GOTOFF_MEDHI16:
6292             case R_SH_GOTOFF_HI16:
6293             case R_SH_GOTPC_LOW16:
6294             case R_SH_GOTPC_MEDLOW16:
6295             case R_SH_GOTPC_MEDHI16:
6296             case R_SH_GOTPC_HI16:
6297 #endif
6298             case R_SH_TLS_GD_32:
6299             case R_SH_TLS_LD_32:
6300             case R_SH_TLS_IE_32:
6301               if (dynobj == NULL)
6302                 htab->root.dynobj = dynobj = abfd;
6303               if (! create_got_section (dynobj, info))
6304                 return FALSE;
6305               break;
6306
6307             default:
6308               break;
6309             }
6310         }
6311
6312       switch (r_type)
6313         {
6314           /* This relocation describes the C++ object vtable hierarchy.
6315              Reconstruct it for later use during GC.  */
6316         case R_SH_GNU_VTINHERIT:
6317           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6318             return FALSE;
6319           break;
6320
6321           /* This relocation describes which C++ vtable entries are actually
6322              used.  Record for later use during GC.  */
6323         case R_SH_GNU_VTENTRY:
6324           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6325             return FALSE;
6326           break;
6327
6328         force_got:
6329         case R_SH_TLS_IE_32:
6330           if (info->shared)
6331             info->flags |= DF_STATIC_TLS;
6332
6333           /* FALLTHROUGH */
6334         case R_SH_TLS_GD_32:
6335         case R_SH_GOT32:
6336 #ifdef INCLUDE_SHMEDIA
6337         case R_SH_GOT_LOW16:
6338         case R_SH_GOT_MEDLOW16:
6339         case R_SH_GOT_MEDHI16:
6340         case R_SH_GOT_HI16:
6341         case R_SH_GOT10BY4:
6342         case R_SH_GOT10BY8:
6343 #endif
6344           switch (r_type)
6345             {
6346             default:
6347               tls_type = GOT_NORMAL;
6348               break;
6349             case R_SH_TLS_GD_32:
6350               tls_type = GOT_TLS_GD;
6351               break;
6352             case R_SH_TLS_IE_32:
6353               tls_type = GOT_TLS_IE;
6354               break;
6355             }
6356
6357           if (h != NULL)
6358             {
6359 #ifdef INCLUDE_SHMEDIA
6360               if (seen_stt_datalabel)
6361                 {
6362                   struct elf_sh_link_hash_entry *eh
6363                     = (struct elf_sh_link_hash_entry *) h;
6364
6365                   eh->datalabel_got.refcount += 1;
6366                 }
6367               else
6368 #endif
6369                 h->got.refcount += 1;
6370               old_tls_type = sh_elf_hash_entry (h)->tls_type;
6371             }
6372           else
6373             {
6374               bfd_signed_vma *local_got_refcounts;
6375
6376               /* This is a global offset table entry for a local
6377                  symbol.  */
6378               local_got_refcounts = elf_local_got_refcounts (abfd);
6379               if (local_got_refcounts == NULL)
6380                 {
6381                   bfd_size_type size;
6382
6383                   size = symtab_hdr->sh_info;
6384                   size *= sizeof (bfd_signed_vma);
6385 #ifdef INCLUDE_SHMEDIA
6386                   /* Reserve space for both the datalabel and
6387                      codelabel local GOT offsets.  */
6388                   size *= 2;
6389 #endif
6390                   size += symtab_hdr->sh_info;
6391                   local_got_refcounts = ((bfd_signed_vma *)
6392                                          bfd_zalloc (abfd, size));
6393                   if (local_got_refcounts == NULL)
6394                     return FALSE;
6395                   elf_local_got_refcounts (abfd) = local_got_refcounts;
6396 #ifdef  INCLUDE_SHMEDIA
6397                   /* Take care of both the datalabel and codelabel local
6398                      GOT offsets.  */
6399                   sh_elf_local_got_tls_type (abfd)
6400                     = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
6401 #else
6402                   sh_elf_local_got_tls_type (abfd)
6403                     = (char *) (local_got_refcounts + symtab_hdr->sh_info);
6404 #endif
6405                 }
6406 #ifdef INCLUDE_SHMEDIA
6407               if (rel->r_addend & 1)
6408                 local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
6409               else
6410 #endif
6411                 local_got_refcounts[r_symndx] += 1;
6412               old_tls_type = sh_elf_local_got_tls_type (abfd) [r_symndx];
6413             }
6414
6415           /* If a TLS symbol is accessed using IE at least once,
6416              there is no point to use dynamic model for it.  */
6417           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
6418               && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
6419             {
6420               if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
6421                 tls_type = GOT_TLS_IE;
6422               else
6423                 {
6424                   (*_bfd_error_handler)
6425                     (_("%s: `%s' accessed both as normal and thread local symbol"),
6426                      bfd_archive_filename (abfd), h->root.root.string);
6427                   return FALSE;
6428                 }
6429             }
6430
6431           if (old_tls_type != tls_type)
6432             {
6433               if (h != NULL)
6434                 sh_elf_hash_entry (h)->tls_type = tls_type;
6435               else
6436                 sh_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
6437             }
6438
6439           break;
6440
6441         case R_SH_TLS_LD_32:
6442           sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
6443           break;
6444
6445         case R_SH_GOTPLT32:
6446 #ifdef INCLUDE_SHMEDIA
6447         case R_SH_GOTPLT_LOW16:
6448         case R_SH_GOTPLT_MEDLOW16:
6449         case R_SH_GOTPLT_MEDHI16:
6450         case R_SH_GOTPLT_HI16:
6451         case R_SH_GOTPLT10BY4:
6452         case R_SH_GOTPLT10BY8:
6453 #endif
6454           /* If this is a local symbol, we resolve it directly without
6455              creating a procedure linkage table entry.  */
6456
6457           if (h == NULL
6458               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
6459               || ! info->shared
6460               || info->symbolic
6461               || h->dynindx == -1)
6462             goto force_got;
6463
6464           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
6465           h->plt.refcount += 1;
6466           ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
6467
6468           break;
6469
6470         case R_SH_PLT32:
6471 #ifdef INCLUDE_SHMEDIA
6472         case R_SH_PLT_LOW16:
6473         case R_SH_PLT_MEDLOW16:
6474         case R_SH_PLT_MEDHI16:
6475         case R_SH_PLT_HI16:
6476 #endif
6477           /* This symbol requires a procedure linkage table entry.  We
6478              actually build the entry in adjust_dynamic_symbol,
6479              because this might be a case of linking PIC code which is
6480              never referenced by a dynamic object, in which case we
6481              don't need to generate a procedure linkage table entry
6482              after all.  */
6483
6484           /* If this is a local symbol, we resolve it directly without
6485              creating a procedure linkage table entry.  */
6486           if (h == NULL)
6487             continue;
6488
6489           if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
6490             break;
6491
6492           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
6493           h->plt.refcount += 1;
6494           break;
6495
6496         case R_SH_DIR32:
6497         case R_SH_REL32:
6498           if (h != NULL && ! info->shared)
6499             {
6500               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
6501               h->plt.refcount += 1;
6502             }
6503
6504           /* If we are creating a shared library, and this is a reloc
6505              against a global symbol, or a non PC relative reloc
6506              against a local symbol, then we need to copy the reloc
6507              into the shared library.  However, if we are linking with
6508              -Bsymbolic, we do not need to copy a reloc against a
6509              global symbol which is defined in an object we are
6510              including in the link (i.e., DEF_REGULAR is set).  At
6511              this point we have not seen all the input files, so it is
6512              possible that DEF_REGULAR is not set now but will be set
6513              later (it is never cleared).  We account for that
6514              possibility below by storing information in the
6515              dyn_relocs field of the hash table entry. A similar
6516              situation occurs when creating shared libraries and symbol
6517              visibility changes render the symbol local.
6518
6519              If on the other hand, we are creating an executable, we
6520              may need to keep relocations for symbols satisfied by a
6521              dynamic library if we manage to avoid copy relocs for the
6522              symbol.  */
6523           if ((info->shared
6524                && (sec->flags & SEC_ALLOC) != 0
6525                && (r_type != R_SH_REL32
6526                    || (h != NULL
6527                        && (! info->symbolic
6528                            || h->root.type == bfd_link_hash_defweak
6529                            || (h->elf_link_hash_flags
6530                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
6531               || (! info->shared
6532                   && (sec->flags & SEC_ALLOC) != 0
6533                   && h != NULL
6534                   && (h->root.type == bfd_link_hash_defweak
6535                       || (h->elf_link_hash_flags
6536                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6537             {
6538               struct elf_sh_dyn_relocs *p;
6539               struct elf_sh_dyn_relocs **head;
6540
6541               if (dynobj == NULL)
6542                 htab->root.dynobj = dynobj = abfd;
6543
6544               /* When creating a shared object, we must copy these
6545                  reloc types into the output file.  We create a reloc
6546                  section in dynobj and make room for this reloc.  */
6547               if (sreloc == NULL)
6548                 {
6549                   const char *name;
6550
6551                   name = (bfd_elf_string_from_elf_section
6552                           (abfd,
6553                            elf_elfheader (abfd)->e_shstrndx,
6554                            elf_section_data (sec)->rel_hdr.sh_name));
6555                   if (name == NULL)
6556                     return FALSE;
6557
6558                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6559                               && strcmp (bfd_get_section_name (abfd, sec),
6560                                          name + 5) == 0);
6561
6562                   sreloc = bfd_get_section_by_name (dynobj, name);
6563                   if (sreloc == NULL)
6564                     {
6565                       flagword flags;
6566
6567                       sreloc = bfd_make_section (dynobj, name);
6568                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
6569                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6570                       if ((sec->flags & SEC_ALLOC) != 0)
6571                         flags |= SEC_ALLOC | SEC_LOAD;
6572                       if (sreloc == NULL
6573                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
6574                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6575                         return FALSE;
6576                     }
6577                   if (sec->flags & SEC_READONLY)
6578                     info->flags |= DF_TEXTREL;
6579                   elf_section_data (sec)->sreloc = sreloc;
6580                 }
6581
6582               /* If this is a global symbol, we count the number of
6583                  relocations we need for this symbol.  */
6584               if (h != NULL)
6585                 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6586               else
6587                 {
6588                   asection *s;
6589
6590                   /* Track dynamic relocs needed for local syms too.  */
6591                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6592                                                  sec, r_symndx);
6593                   if (s == NULL)
6594                     return FALSE;
6595
6596                   head = ((struct elf_sh_dyn_relocs **)
6597                           &elf_section_data (s)->local_dynrel);
6598                 }
6599
6600               p = *head;
6601               if (p == NULL || p->sec != sec)
6602                 {
6603                   bfd_size_type amt = sizeof (*p);
6604                   p = ((struct elf_sh_dyn_relocs *) bfd_alloc (dynobj, amt));
6605                   if (p == NULL)
6606                     return FALSE;
6607                   p->next = *head;
6608                   *head = p;
6609                   p->sec = sec;
6610                   p->count = 0;
6611                   p->pc_count = 0;
6612                   p->tls_tpoff32 = FALSE;
6613                 }
6614
6615               p->count += 1;
6616               if (r_type == R_SH_REL32)
6617                 p->pc_count += 1;
6618             }
6619
6620           break;
6621
6622         case R_SH_TLS_LE_32:
6623           if (info->shared)
6624             {
6625               (*_bfd_error_handler) (_("%s: TLS local exec code cannot be linked into shared objects"),
6626                                      bfd_archive_filename (abfd));
6627               return FALSE;
6628             }
6629
6630           if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_LD_32)
6631             break;
6632
6633           /* FALLTHROUGH */
6634         case R_SH_TLS_LDO_32:
6635           /* We make a R_SH_TLS_TPOFF32 relocation. Count it as a
6636              copy relocation.  */
6637           if (! info->shared)
6638             {
6639               struct elf_sh_dyn_relocs *p;
6640               struct elf_sh_dyn_relocs **head;
6641
6642               if (dynobj == NULL)
6643                 htab->root.dynobj = dynobj = abfd;
6644
6645               if (sreloc == NULL)
6646                 {
6647                   const char *name;
6648
6649                   name = (bfd_elf_string_from_elf_section
6650                           (abfd,
6651                            elf_elfheader (abfd)->e_shstrndx,
6652                            elf_section_data (sec)->rel_hdr.sh_name));
6653                   if (name == NULL)
6654                     return FALSE;
6655
6656                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6657                               && strcmp (bfd_get_section_name (abfd, sec),
6658                                          name + 5) == 0);
6659
6660                   sreloc = bfd_get_section_by_name (dynobj, name);
6661                   if (sreloc == NULL)
6662                     {
6663                       flagword flags;
6664
6665                       sreloc = bfd_make_section (dynobj, name);
6666                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
6667                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6668                       if ((sec->flags & SEC_ALLOC) != 0)
6669                         flags |= SEC_ALLOC | SEC_LOAD;
6670                       if (sreloc == NULL
6671                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
6672                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6673                         return FALSE;
6674                     }
6675                   elf_section_data (sec)->sreloc = sreloc;
6676                   if (sec->flags & SEC_READONLY)
6677                     info->flags |= DF_TEXTREL;
6678                 }
6679
6680               /* If this is a global symbol, we count the number of
6681                  relocations we need for this symbol.  */
6682               if (h != NULL)
6683                 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6684               else
6685                 {
6686                   asection *s;
6687
6688                   /* Track dynamic relocs needed for local syms too.  */
6689                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6690                                                  sec, r_symndx);
6691                   if (s == NULL)
6692                     return FALSE;
6693
6694                   head = ((struct elf_sh_dyn_relocs **)
6695                           &elf_section_data (s)->local_dynrel);
6696                 }
6697
6698               p = *head;
6699               if (p == NULL || p->sec != sec)
6700                 {
6701                   bfd_size_type amt = sizeof (*p);
6702                   p = ((struct elf_sh_dyn_relocs *) bfd_alloc (dynobj, amt));
6703                   if (p == NULL)
6704                     return FALSE;
6705                   p->next = *head;
6706                   *head = p;
6707                   p->sec = sec;
6708                   p->count = 0;
6709                   p->pc_count = 0;
6710                   p->tls_tpoff32 = FALSE;
6711                 }
6712
6713               p->count += 1;
6714               p->tls_tpoff32 = TRUE;
6715             }
6716           break;
6717
6718         default:
6719           break;
6720         }
6721     }
6722
6723   return TRUE;
6724 }
6725
6726 #ifndef sh_elf_set_mach_from_flags
6727 static bfd_boolean
6728 sh_elf_set_mach_from_flags (abfd)
6729      bfd *abfd;
6730 {
6731   flagword flags = elf_elfheader (abfd)->e_flags;
6732
6733   switch (flags & EF_SH_MACH_MASK)
6734     {
6735     case EF_SH1:
6736       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
6737       break;
6738     case EF_SH2:
6739       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
6740       break;
6741     case EF_SH2E:
6742       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2e);
6743       break;
6744     case EF_SH_DSP:
6745       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
6746       break;
6747     case EF_SH3:
6748       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
6749       break;
6750     case EF_SH3_DSP:
6751       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
6752       break;
6753     case EF_SH3E:
6754       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
6755       break;
6756     case EF_SH_UNKNOWN:
6757     case EF_SH4:
6758       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
6759       break;
6760     default:
6761       return FALSE;
6762     }
6763   return TRUE;
6764 }
6765 #endif /* not sh_elf_set_mach_from_flags */
6766
6767 #ifndef sh_elf_set_private_flags
6768 /* Function to keep SH specific file flags.  */
6769
6770 static bfd_boolean
6771 sh_elf_set_private_flags (abfd, flags)
6772      bfd *abfd;
6773      flagword flags;
6774 {
6775   BFD_ASSERT (! elf_flags_init (abfd)
6776               || elf_elfheader (abfd)->e_flags == flags);
6777
6778   elf_elfheader (abfd)->e_flags = flags;
6779   elf_flags_init (abfd) = TRUE;
6780   return sh_elf_set_mach_from_flags (abfd);
6781 }
6782 #endif /* not sh_elf_set_private_flags */
6783
6784 #ifndef sh_elf_copy_private_data
6785 /* Copy backend specific data from one object module to another */
6786
6787 static bfd_boolean
6788 sh_elf_copy_private_data (ibfd, obfd)
6789      bfd * ibfd;
6790      bfd * obfd;
6791 {
6792   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6793       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6794     return TRUE;
6795
6796   return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
6797 }
6798 #endif /* not sh_elf_copy_private_data */
6799
6800 #ifndef sh_elf_merge_private_data
6801 /* This routine checks for linking big and little endian objects
6802    together, and for linking sh-dsp with sh3e / sh4 objects.  */
6803
6804 static bfd_boolean
6805 sh_elf_merge_private_data (ibfd, obfd)
6806      bfd *ibfd;
6807      bfd *obfd;
6808 {
6809   flagword old_flags, new_flags;
6810
6811   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
6812     return FALSE;
6813
6814   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6815       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6816     return TRUE;
6817
6818   if (! elf_flags_init (obfd))
6819     {
6820       /* This happens when ld starts out with a 'blank' output file.  */
6821       elf_flags_init (obfd) = TRUE;
6822       elf_elfheader (obfd)->e_flags = EF_SH1;
6823     }
6824   old_flags = elf_elfheader (obfd)->e_flags;
6825   new_flags = elf_elfheader (ibfd)->e_flags;
6826   if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
6827       || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
6828     {
6829       (*_bfd_error_handler)
6830         ("%s: uses %s instructions while previous modules use %s instructions",
6831          bfd_archive_filename (ibfd),
6832          EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
6833          EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
6834       bfd_set_error (bfd_error_bad_value);
6835       return FALSE;
6836     }
6837   elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
6838
6839   return sh_elf_set_mach_from_flags (obfd);
6840 }
6841 #endif /* not sh_elf_merge_private_data */
6842
6843 /* Override the generic function because we need to store sh_elf_obj_tdata
6844    as the specific tdata.  We set also the machine architecture from flags
6845    here.  */
6846
6847 static bfd_boolean
6848 sh_elf_object_p (abfd)
6849   bfd *abfd;
6850 {
6851   struct sh_elf_obj_tdata *new_tdata;
6852   bfd_size_type amt = sizeof (struct sh_elf_obj_tdata);
6853
6854   if (!sh_elf_set_mach_from_flags (abfd))
6855     return FALSE;
6856
6857   /* Allocate our special target data.  */
6858   new_tdata = bfd_zalloc (abfd, amt);
6859   if (new_tdata == NULL)
6860     return FALSE;
6861   new_tdata->root = *abfd->tdata.elf_obj_data;
6862   abfd->tdata.any = new_tdata;
6863   return TRUE;
6864 }
6865
6866 /* Finish up dynamic symbol handling.  We set the contents of various
6867    dynamic sections here.  */
6868
6869 static bfd_boolean
6870 sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
6871      bfd *output_bfd;
6872      struct bfd_link_info *info;
6873      struct elf_link_hash_entry *h;
6874      Elf_Internal_Sym *sym;
6875 {
6876   struct elf_sh_link_hash_table *htab;
6877   bfd *dynobj;
6878
6879   htab = sh_elf_hash_table (info);
6880   dynobj = htab->root.dynobj;
6881
6882   if (h->plt.offset != (bfd_vma) -1)
6883     {
6884       asection *splt;
6885       asection *sgot;
6886       asection *srel;
6887
6888       bfd_vma plt_index;
6889       bfd_vma got_offset;
6890       Elf_Internal_Rela rel;
6891       bfd_byte *loc;
6892
6893       /* This symbol has an entry in the procedure linkage table.  Set
6894          it up.  */
6895
6896       BFD_ASSERT (h->dynindx != -1);
6897
6898       splt = htab->splt;
6899       sgot = htab->sgotplt;
6900       srel = htab->srelplt;
6901       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
6902
6903       /* Get the index in the procedure linkage table which
6904          corresponds to this symbol.  This is the index of this symbol
6905          in all the symbols for which we are making plt entries.  The
6906          first entry in the procedure linkage table is reserved.  */
6907       plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
6908
6909       /* Get the offset into the .got table of the entry that
6910          corresponds to this function.  Each .got entry is 4 bytes.
6911          The first three are reserved.  */
6912       got_offset = (plt_index + 3) * 4;
6913
6914 #ifdef GOT_BIAS
6915       if (info->shared)
6916         got_offset -= GOT_BIAS;
6917 #endif
6918
6919       /* Fill in the entry in the procedure linkage table.  */
6920       if (! info->shared)
6921         {
6922           if (elf_sh_plt_entry == NULL)
6923             {
6924               elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
6925                                   elf_sh_plt_entry_be : elf_sh_plt_entry_le);
6926             }
6927           memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
6928                   elf_sh_sizeof_plt (info));
6929 #ifdef INCLUDE_SHMEDIA
6930           movi_shori_putval (output_bfd,
6931                              (sgot->output_section->vma
6932                               + sgot->output_offset
6933                               + got_offset),
6934                              (splt->contents + h->plt.offset
6935                               + elf_sh_plt_symbol_offset (info)));
6936
6937           /* Set bottom bit because its for a branch to SHmedia */
6938           movi_shori_putval (output_bfd,
6939                              (splt->output_section->vma + splt->output_offset)
6940                              | 1,
6941                              (splt->contents + h->plt.offset
6942                               + elf_sh_plt_plt0_offset (info)));
6943 #else
6944           bfd_put_32 (output_bfd,
6945                       (sgot->output_section->vma
6946                        + sgot->output_offset
6947                        + got_offset),
6948                       (splt->contents + h->plt.offset
6949                        + elf_sh_plt_symbol_offset (info)));
6950
6951           bfd_put_32 (output_bfd,
6952                       (splt->output_section->vma + splt->output_offset),
6953                       (splt->contents + h->plt.offset
6954                        + elf_sh_plt_plt0_offset (info)));
6955 #endif
6956         }
6957       else
6958         {
6959           if (elf_sh_pic_plt_entry == NULL)
6960             {
6961               elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
6962                                       elf_sh_pic_plt_entry_be :
6963                                       elf_sh_pic_plt_entry_le);
6964             }
6965           memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
6966                   elf_sh_sizeof_plt (info));
6967 #ifdef INCLUDE_SHMEDIA
6968           movi_shori_putval (output_bfd, got_offset,
6969                              (splt->contents + h->plt.offset
6970                               + elf_sh_plt_symbol_offset (info)));
6971 #else
6972           bfd_put_32 (output_bfd, got_offset,
6973                       (splt->contents + h->plt.offset
6974                        + elf_sh_plt_symbol_offset (info)));
6975 #endif
6976         }
6977
6978 #ifdef GOT_BIAS
6979       if (info->shared)
6980         got_offset += GOT_BIAS;
6981 #endif
6982
6983 #ifdef INCLUDE_SHMEDIA
6984       movi_shori_putval (output_bfd,
6985                          plt_index * sizeof (Elf32_External_Rela),
6986                          (splt->contents + h->plt.offset
6987                           + elf_sh_plt_reloc_offset (info)));
6988 #else
6989       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
6990                   (splt->contents + h->plt.offset
6991                    + elf_sh_plt_reloc_offset (info)));
6992 #endif
6993
6994       /* Fill in the entry in the global offset table.  */
6995       bfd_put_32 (output_bfd,
6996                   (splt->output_section->vma
6997                    + splt->output_offset
6998                    + h->plt.offset
6999                    + elf_sh_plt_temp_offset (info)),
7000                   sgot->contents + got_offset);
7001
7002       /* Fill in the entry in the .rela.plt section.  */
7003       rel.r_offset = (sgot->output_section->vma
7004                       + sgot->output_offset
7005                       + got_offset);
7006       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
7007       rel.r_addend = 0;
7008 #ifdef GOT_BIAS
7009       rel.r_addend = GOT_BIAS;
7010 #endif
7011       loc = srel->contents + plt_index * sizeof (Elf32_External_Rela);
7012       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7013
7014       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
7015         {
7016           /* Mark the symbol as undefined, rather than as defined in
7017              the .plt section.  Leave the value alone.  */
7018           sym->st_shndx = SHN_UNDEF;
7019         }
7020     }
7021
7022   if (h->got.offset != (bfd_vma) -1
7023       && sh_elf_hash_entry (h)->tls_type != GOT_TLS_GD
7024       && sh_elf_hash_entry (h)->tls_type != GOT_TLS_IE)
7025     {
7026       asection *sgot;
7027       asection *srel;
7028       Elf_Internal_Rela rel;
7029       bfd_byte *loc;
7030
7031       /* This symbol has an entry in the global offset table.  Set it
7032          up.  */
7033
7034       sgot = htab->sgot;
7035       srel = htab->srelgot;
7036       BFD_ASSERT (sgot != NULL && srel != NULL);
7037
7038       rel.r_offset = (sgot->output_section->vma
7039                       + sgot->output_offset
7040                       + (h->got.offset &~ (bfd_vma) 1));
7041
7042       /* If this is a static link, or it is a -Bsymbolic link and the
7043          symbol is defined locally or was forced to be local because
7044          of a version file, we just want to emit a RELATIVE reloc.
7045          The entry in the global offset table will already have been
7046          initialized in the relocate_section function.  */
7047       if (info->shared
7048           && (info->symbolic
7049               || h->dynindx == -1
7050               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
7051           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
7052         {
7053           rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7054           rel.r_addend = (h->root.u.def.value
7055                           + h->root.u.def.section->output_section->vma
7056                           + h->root.u.def.section->output_offset);
7057         }
7058       else
7059         {
7060           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
7061           rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7062           rel.r_addend = 0;
7063         }
7064
7065       loc = srel->contents;
7066       loc += srel->reloc_count++ * sizeof (Elf32_External_Rela);
7067       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7068     }
7069
7070 #ifdef INCLUDE_SHMEDIA
7071   {
7072     struct elf_sh_link_hash_entry *eh;
7073
7074     eh = (struct elf_sh_link_hash_entry *) h;
7075     if (eh->datalabel_got.offset != (bfd_vma) -1)
7076       {
7077         asection *sgot;
7078         asection *srel;
7079         Elf_Internal_Rela rel;
7080         bfd_byte *loc;
7081
7082         /* This symbol has a datalabel entry in the global offset table.
7083            Set it up.  */
7084
7085         sgot = htab->sgot;
7086         srel = htab->srelgot;
7087         BFD_ASSERT (sgot != NULL && srel != NULL);
7088
7089         rel.r_offset = (sgot->output_section->vma
7090                         + sgot->output_offset
7091                         + (eh->datalabel_got.offset &~ (bfd_vma) 1));
7092
7093         /* If this is a static link, or it is a -Bsymbolic link and the
7094            symbol is defined locally or was forced to be local because
7095            of a version file, we just want to emit a RELATIVE reloc.
7096            The entry in the global offset table will already have been
7097            initialized in the relocate_section function.  */
7098         if (info->shared
7099             && (info->symbolic
7100                 || h->dynindx == -1
7101                 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
7102             && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
7103           {
7104             rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7105             rel.r_addend = (h->root.u.def.value
7106                             + h->root.u.def.section->output_section->vma
7107                             + h->root.u.def.section->output_offset);
7108           }
7109         else
7110           {
7111             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents
7112                         + eh->datalabel_got.offset);
7113             rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7114             rel.r_addend = 0;
7115           }
7116
7117         loc = srel->contents;
7118         loc += srel->reloc_count++ * sizeof (Elf32_External_Rela);
7119         bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7120       }
7121   }
7122 #endif
7123
7124   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
7125     {
7126       asection *s;
7127       Elf_Internal_Rela rel;
7128       bfd_byte *loc;
7129
7130       /* This symbol needs a copy reloc.  Set it up.  */
7131
7132       BFD_ASSERT (h->dynindx != -1
7133                   && (h->root.type == bfd_link_hash_defined
7134                       || h->root.type == bfd_link_hash_defweak));
7135
7136       s = bfd_get_section_by_name (h->root.u.def.section->owner,
7137                                    ".rela.bss");
7138       BFD_ASSERT (s != NULL);
7139
7140       rel.r_offset = (h->root.u.def.value
7141                       + h->root.u.def.section->output_section->vma
7142                       + h->root.u.def.section->output_offset);
7143       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
7144       rel.r_addend = 0;
7145       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
7146       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7147     }
7148
7149   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
7150   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7151       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7152     sym->st_shndx = SHN_ABS;
7153
7154   return TRUE;
7155 }
7156
7157 /* Finish up the dynamic sections.  */
7158
7159 static bfd_boolean
7160 sh_elf_finish_dynamic_sections (output_bfd, info)
7161      bfd *output_bfd;
7162      struct bfd_link_info *info;
7163 {
7164   struct elf_sh_link_hash_table *htab;
7165   bfd *dynobj;
7166   asection *sgot;
7167   asection *sdyn;
7168
7169   htab = sh_elf_hash_table (info);
7170   dynobj = htab->root.dynobj;
7171
7172   sgot = htab->sgotplt;
7173   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7174
7175   if (htab->root.dynamic_sections_created)
7176     {
7177       asection *splt;
7178       Elf32_External_Dyn *dyncon, *dynconend;
7179
7180       BFD_ASSERT (sgot != NULL && sdyn != NULL);
7181
7182       dyncon = (Elf32_External_Dyn *) sdyn->contents;
7183       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
7184       for (; dyncon < dynconend; dyncon++)
7185         {
7186           Elf_Internal_Dyn dyn;
7187           asection *s;
7188 #ifdef INCLUDE_SHMEDIA
7189           const char *name;
7190 #endif
7191
7192           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
7193
7194           switch (dyn.d_tag)
7195             {
7196             default:
7197               break;
7198
7199 #ifdef INCLUDE_SHMEDIA
7200             case DT_INIT:
7201               name = info->init_function;
7202               goto get_sym;
7203
7204             case DT_FINI:
7205               name = info->fini_function;
7206             get_sym:
7207               if (dyn.d_un.d_val != 0)
7208                 {
7209                   struct elf_link_hash_entry *h;
7210
7211                   h = elf_link_hash_lookup (&htab->root, name,
7212                                             FALSE, FALSE, TRUE);
7213                   if (h != NULL && (h->other & STO_SH5_ISA32))
7214                     {
7215                       dyn.d_un.d_val |= 1;
7216                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7217                     }
7218                 }
7219               break;
7220 #endif
7221
7222             case DT_PLTGOT:
7223               s = htab->sgot->output_section;
7224               goto get_vma;
7225
7226             case DT_JMPREL:
7227               s = htab->srelplt->output_section;
7228             get_vma:
7229               BFD_ASSERT (s != NULL);
7230               dyn.d_un.d_ptr = s->vma;
7231               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7232               break;
7233
7234             case DT_PLTRELSZ:
7235               s = htab->srelplt->output_section;
7236               BFD_ASSERT (s != NULL);
7237               if (s->_cooked_size != 0)
7238                 dyn.d_un.d_val = s->_cooked_size;
7239               else
7240                 dyn.d_un.d_val = s->_raw_size;
7241               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7242               break;
7243
7244             case DT_RELASZ:
7245               /* My reading of the SVR4 ABI indicates that the
7246                  procedure linkage table relocs (DT_JMPREL) should be
7247                  included in the overall relocs (DT_RELA).  This is
7248                  what Solaris does.  However, UnixWare can not handle
7249                  that case.  Therefore, we override the DT_RELASZ entry
7250                  here to make it not include the JMPREL relocs.  Since
7251                  the linker script arranges for .rela.plt to follow all
7252                  other relocation sections, we don't have to worry
7253                  about changing the DT_RELA entry.  */
7254               if (htab->srelplt != NULL)
7255                 {
7256                   s = htab->srelplt->output_section;
7257                   if (s->_cooked_size != 0)
7258                     dyn.d_un.d_val -= s->_cooked_size;
7259                   else
7260                     dyn.d_un.d_val -= s->_raw_size;
7261                 }
7262               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7263               break;
7264             }
7265         }
7266
7267       /* Fill in the first entry in the procedure linkage table.  */
7268       splt = htab->splt;
7269       if (splt && splt->_raw_size > 0)
7270         {
7271           if (info->shared)
7272             {
7273               if (elf_sh_pic_plt_entry == NULL)
7274                 {
7275                   elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
7276                                           elf_sh_pic_plt_entry_be :
7277                                           elf_sh_pic_plt_entry_le);
7278                 }
7279               memcpy (splt->contents, elf_sh_pic_plt_entry,
7280                       elf_sh_sizeof_plt (info));
7281             }
7282           else
7283             {
7284               if (elf_sh_plt0_entry == NULL)
7285                 {
7286                   elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
7287                                        elf_sh_plt0_entry_be :
7288                                        elf_sh_plt0_entry_le);
7289                 }
7290               memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
7291 #ifdef INCLUDE_SHMEDIA
7292               movi_shori_putval (output_bfd,
7293                                  sgot->output_section->vma
7294                                  + sgot->output_offset,
7295                                  splt->contents
7296                                  + elf_sh_plt0_gotplt_offset (info));
7297 #else
7298               bfd_put_32 (output_bfd,
7299                           sgot->output_section->vma + sgot->output_offset + 4,
7300                           splt->contents + elf_sh_plt0_gotid_offset (info));
7301               bfd_put_32 (output_bfd,
7302                           sgot->output_section->vma + sgot->output_offset + 8,
7303                           splt->contents + elf_sh_plt0_linker_offset (info));
7304 #endif
7305             }
7306
7307           /* UnixWare sets the entsize of .plt to 4, although that doesn't
7308              really seem like the right value.  */
7309           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7310         }
7311     }
7312
7313   /* Fill in the first three entries in the global offset table.  */
7314   if (sgot && sgot->_raw_size > 0)
7315     {
7316       if (sdyn == NULL)
7317         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7318       else
7319         bfd_put_32 (output_bfd,
7320                     sdyn->output_section->vma + sdyn->output_offset,
7321                     sgot->contents);
7322       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7323       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7324
7325       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7326     }
7327
7328   return TRUE;
7329 }
7330
7331 static enum elf_reloc_type_class
7332 sh_elf_reloc_type_class (rela)
7333      const Elf_Internal_Rela *rela;
7334 {
7335   switch ((int) ELF32_R_TYPE (rela->r_info))
7336     {
7337     case R_SH_RELATIVE:
7338       return reloc_class_relative;
7339     case R_SH_JMP_SLOT:
7340       return reloc_class_plt;
7341     case R_SH_COPY:
7342       return reloc_class_copy;
7343     default:
7344       return reloc_class_normal;
7345     }
7346 }
7347
7348 /* Support for Linux core dump NOTE sections.  */
7349 static bfd_boolean
7350 elf32_shlin_grok_prstatus (abfd, note)
7351      bfd *abfd;
7352      Elf_Internal_Note *note;
7353 {
7354   int offset;
7355   unsigned int raw_size;
7356
7357   switch (note->descsz)
7358     {
7359       default:
7360         return FALSE;
7361
7362       case 168:         /* Linux/SH */
7363         /* pr_cursig */
7364         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
7365
7366         /* pr_pid */
7367         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
7368
7369         /* pr_reg */
7370         offset = 72;
7371         raw_size = 92;
7372
7373         break;
7374     }
7375
7376   /* Make a ".reg/999" section.  */
7377   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7378                                           raw_size, note->descpos + offset);
7379 }
7380
7381 static bfd_boolean
7382 elf32_shlin_grok_psinfo (abfd, note)
7383      bfd *abfd;
7384      Elf_Internal_Note *note;
7385 {
7386   switch (note->descsz)
7387     {
7388       default:
7389         return FALSE;
7390
7391       case 124:         /* Linux/SH elf_prpsinfo */
7392         elf_tdata (abfd)->core_program
7393          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
7394         elf_tdata (abfd)->core_command
7395          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
7396     }
7397
7398   /* Note that for some reason, a spurious space is tacked
7399      onto the end of the args in some (at least one anyway)
7400      implementations, so strip it off if it exists.  */
7401
7402   {
7403     char *command = elf_tdata (abfd)->core_command;
7404     int n = strlen (command);
7405
7406     if (0 < n && command[n - 1] == ' ')
7407       command[n - 1] = '\0';
7408   }
7409
7410   return TRUE;
7411 }
7412
7413 #define TARGET_BIG_SYM          bfd_elf32_sh_vec
7414 #define TARGET_BIG_NAME         "elf32-sh"
7415 #define TARGET_LITTLE_SYM       bfd_elf32_shl_vec
7416 #define TARGET_LITTLE_NAME      "elf32-shl"
7417 #define ELF_ARCH                bfd_arch_sh
7418 #define ELF_MACHINE_CODE        EM_SH
7419 #define ELF_MAXPAGESIZE         128
7420
7421 #define elf_symbol_leading_char '_'
7422
7423 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7424 #define elf_info_to_howto               sh_elf_info_to_howto
7425 #define bfd_elf32_bfd_relax_section     sh_elf_relax_section
7426 #define elf_backend_relocate_section    sh_elf_relocate_section
7427 #define bfd_elf32_bfd_get_relocated_section_contents \
7428                                         sh_elf_get_relocated_section_contents
7429 #define bfd_elf32_mkobject              sh_elf_mkobject
7430 #define elf_backend_object_p            sh_elf_object_p
7431 #define bfd_elf32_bfd_set_private_bfd_flags \
7432                                         sh_elf_set_private_flags
7433 #define bfd_elf32_bfd_copy_private_bfd_data \
7434                                         sh_elf_copy_private_data
7435 #define bfd_elf32_bfd_merge_private_bfd_data \
7436                                         sh_elf_merge_private_data
7437
7438 #define elf_backend_gc_mark_hook        sh_elf_gc_mark_hook
7439 #define elf_backend_gc_sweep_hook       sh_elf_gc_sweep_hook
7440 #define elf_backend_check_relocs        sh_elf_check_relocs
7441 #define elf_backend_copy_indirect_symbol \
7442                                         sh_elf_copy_indirect_symbol
7443 #define elf_backend_create_dynamic_sections \
7444                                         sh_elf_create_dynamic_sections
7445 #define bfd_elf32_bfd_link_hash_table_create \
7446                                         sh_elf_link_hash_table_create
7447 #define elf_backend_adjust_dynamic_symbol \
7448                                         sh_elf_adjust_dynamic_symbol
7449 #define elf_backend_size_dynamic_sections \
7450                                         sh_elf_size_dynamic_sections
7451 #define elf_backend_finish_dynamic_symbol \
7452                                         sh_elf_finish_dynamic_symbol
7453 #define elf_backend_finish_dynamic_sections \
7454                                         sh_elf_finish_dynamic_sections
7455 #define elf_backend_reloc_type_class    sh_elf_reloc_type_class
7456
7457 #define elf_backend_can_gc_sections     1
7458 #define elf_backend_can_refcount        1
7459 #define elf_backend_want_got_plt        1
7460 #define elf_backend_plt_readonly        1
7461 #define elf_backend_want_plt_sym        0
7462 #define elf_backend_got_header_size     12
7463 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
7464
7465 #ifndef INCLUDE_SHMEDIA
7466
7467 #include "elf32-target.h"
7468
7469 /* NetBSD support.  */
7470 #undef  TARGET_BIG_SYM
7471 #define TARGET_BIG_SYM                  bfd_elf32_shnbsd_vec
7472 #undef  TARGET_BIG_NAME
7473 #define TARGET_BIG_NAME                 "elf32-sh-nbsd"
7474 #undef  TARGET_LITTLE_SYM
7475 #define TARGET_LITTLE_SYM               bfd_elf32_shlnbsd_vec
7476 #undef  TARGET_LITTLE_NAME
7477 #define TARGET_LITTLE_NAME              "elf32-shl-nbsd"
7478 #undef  ELF_MAXPAGESIZE
7479 #define ELF_MAXPAGESIZE                 0x10000
7480 #undef  elf_symbol_leading_char
7481 #define elf_symbol_leading_char         0
7482 #undef  elf32_bed
7483 #define elf32_bed                       elf32_sh_nbsd_bed
7484
7485 #include "elf32-target.h"
7486
7487
7488 /* Linux support.  */
7489 #undef  TARGET_BIG_SYM
7490 #define TARGET_BIG_SYM                  bfd_elf32_shblin_vec
7491 #undef  TARGET_BIG_NAME
7492 #define TARGET_BIG_NAME                 "elf32-shbig-linux"
7493 #undef  TARGET_LITTLE_SYM
7494 #define TARGET_LITTLE_SYM               bfd_elf32_shlin_vec
7495 #undef  TARGET_LITTLE_NAME
7496 #define TARGET_LITTLE_NAME              "elf32-sh-linux"
7497
7498 #undef  elf_backend_grok_prstatus
7499 #define elf_backend_grok_prstatus       elf32_shlin_grok_prstatus
7500 #undef  elf_backend_grok_psinfo
7501 #define elf_backend_grok_psinfo         elf32_shlin_grok_psinfo
7502 #undef  elf32_bed
7503 #define elf32_bed                       elf32_sh_lin_bed
7504
7505 #include "elf32-target.h"
7506
7507 #endif /* INCLUDE_SHMEDIA */