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