bfd/elf32-sh.c

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