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