bfd/elf32-sh.c

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