bfd/elf32-sh.c

   1 /* Hitachi SH specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4    Contributed by Ian Lance Taylor, Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "bfdlink.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/sh.h"
  28
  29 static bfd_reloc_status_type sh_elf_reloc
  30   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  31 static bfd_reloc_status_type sh_elf_ignore_reloc
  32   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  33 static reloc_howto_type *sh_elf_reloc_type_lookup
  34   PARAMS ((bfd *, bfd_reloc_code_real_type));
  35 static void sh_elf_info_to_howto
  36   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  37 static boolean sh_elf_set_private_flags
  38   PARAMS ((bfd *, flagword));
  39 static boolean sh_elf_copy_private_data
  40   PARAMS ((bfd *, bfd *));
  41 static boolean sh_elf_merge_private_data
  42   PARAMS ((bfd *, bfd *));
  43 static boolean sh_elf_set_mach_from_flags
  44   PARAMS ((bfd *));
  45 static boolean sh_elf_relax_section
  46   PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
  47 static boolean sh_elf_relax_delete_bytes
  48   PARAMS ((bfd *, asection *, bfd_vma, int));
  49 static boolean sh_elf_align_loads
  50   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, boolean *));
  51 static boolean sh_elf_swap_insns
  52   PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
  53 static boolean sh_elf_relocate_section
  54   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  55            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  56 static bfd_byte *sh_elf_get_relocated_section_contents
  57   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
  58            bfd_byte *, boolean, asymbol **));
  59 static boolean sh_elf_check_relocs
  60   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  61            const Elf_Internal_Rela *));
  62 static struct bfd_hash_entry *sh_elf_link_hash_newfunc
  63   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  64 static struct bfd_link_hash_table *sh_elf_link_hash_table_create
  65   PARAMS ((bfd *));
  66 static boolean sh_elf_adjust_dynamic_symbol
  67   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  68 static boolean sh_elf_size_dynamic_sections
  69   PARAMS ((bfd *, struct bfd_link_info *));
  70 static boolean sh_elf_finish_dynamic_symbol
  71   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  72            Elf_Internal_Sym *));
  73 static boolean sh_elf_finish_dynamic_sections
  74   PARAMS ((bfd *, struct bfd_link_info *));
  75
  76 /* The name of the dynamic interpreter.  This is put in the .interp
  77    section.  */
  78
  79 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
  80
  81 static reloc_howto_type sh_elf_howto_table[] =
  82 {
  83   /* No relocation.  */
  84   HOWTO (R_SH_NONE,             /* type */
  85          0,                     /* rightshift */
  86          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  87          0,                     /* bitsize */
  88          false,                 /* pc_relative */
  89          0,                     /* bitpos */
  90          complain_overflow_dont, /* complain_on_overflow */
  91          sh_elf_ignore_reloc,   /* special_function */
  92          "R_SH_NONE",           /* name */
  93          false,                 /* partial_inplace */
  94          0,                     /* src_mask */
  95          0,                     /* dst_mask */
  96          false),                /* pcrel_offset */
  97
  98   /* 32 bit absolute relocation.  Setting partial_inplace to true and
  99      src_mask to a non-zero value is similar to the COFF toolchain.  */
 100   HOWTO (R_SH_DIR32,            /* type */
 101          0,                     /* rightshift */
 102          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 103          32,                    /* bitsize */
 104          false,                 /* pc_relative */
 105          0,                     /* bitpos */
 106          complain_overflow_bitfield, /* complain_on_overflow */
 107          sh_elf_reloc,          /* special_function */
 108          "R_SH_DIR32",          /* name */
 109          true,                  /* partial_inplace */
 110          0xffffffff,            /* src_mask */
 111          0xffffffff,            /* dst_mask */
 112          false),                /* pcrel_offset */
 113
 114   /* 32 bit PC relative relocation.  */
 115   HOWTO (R_SH_REL32,            /* type */
 116          0,                     /* rightshift */
 117          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 118          32,                    /* bitsize */
 119          true,                  /* pc_relative */
 120          0,                     /* bitpos */
 121          complain_overflow_signed, /* complain_on_overflow */
 122          sh_elf_ignore_reloc,   /* special_function */
 123          "R_SH_REL32",          /* name */
 124          false,                 /* partial_inplace */
 125          0,                     /* src_mask */
 126          0xffffffff,            /* dst_mask */
 127          true),                 /* pcrel_offset */
 128
 129   /* 8 bit PC relative branch divided by 2.  */
 130   HOWTO (R_SH_DIR8WPN,          /* type */
 131          1,                     /* rightshift */
 132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 133          8,                     /* bitsize */
 134          true,                  /* pc_relative */
 135          0,                     /* bitpos */
 136          complain_overflow_signed, /* complain_on_overflow */
 137          sh_elf_ignore_reloc,   /* special_function */
 138          "R_SH_DIR8WPN",        /* name */
 139          true,                  /* partial_inplace */
 140          0xff,                  /* src_mask */
 141          0xff,                  /* dst_mask */
 142          true),                 /* pcrel_offset */
 143
 144   /* 12 bit PC relative branch divided by 2.  */
 145   HOWTO (R_SH_IND12W,           /* type */
 146          1,                     /* rightshift */
 147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 148          12,                    /* bitsize */
 149          true,                  /* pc_relative */
 150          0,                     /* bitpos */
 151          complain_overflow_signed, /* complain_on_overflow */
 152          sh_elf_reloc,          /* special_function */
 153          "R_SH_IND12W",         /* name */
 154          true,                  /* partial_inplace */
 155          0xfff,                 /* src_mask */
 156          0xfff,                 /* dst_mask */
 157          true),                 /* pcrel_offset */
 158
 159   /* 8 bit unsigned PC relative divided by 4.  */
 160   HOWTO (R_SH_DIR8WPL,          /* type */
 161          2,                     /* rightshift */
 162          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 163          8,                     /* bitsize */
 164          true,                  /* pc_relative */
 165          0,                     /* bitpos */
 166          complain_overflow_unsigned, /* complain_on_overflow */
 167          sh_elf_ignore_reloc,   /* special_function */
 168          "R_SH_DIR8WPL",        /* name */
 169          true,                  /* partial_inplace */
 170          0xff,                  /* src_mask */
 171          0xff,                  /* dst_mask */
 172          true),                 /* pcrel_offset */
 173
 174   /* 8 bit unsigned PC relative divided by 2.  */
 175   HOWTO (R_SH_DIR8WPZ,          /* type */
 176          1,                     /* rightshift */
 177          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 178          8,                     /* bitsize */
 179          true,                  /* pc_relative */
 180          0,                     /* bitpos */
 181          complain_overflow_unsigned, /* complain_on_overflow */
 182          sh_elf_ignore_reloc,   /* special_function */
 183          "R_SH_DIR8WPZ",        /* name */
 184          true,                  /* partial_inplace */
 185          0xff,                  /* src_mask */
 186          0xff,                  /* dst_mask */
 187          true),                 /* pcrel_offset */
 188
 189   /* 8 bit GBR relative.  FIXME: This only makes sense if we have some
 190      special symbol for the GBR relative area, and that is not
 191      implemented.  */
 192   HOWTO (R_SH_DIR8BP,           /* type */
 193          0,                     /* rightshift */
 194          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 195          8,                     /* bitsize */
 196          false,                 /* pc_relative */
 197          0,                     /* bitpos */
 198          complain_overflow_unsigned, /* complain_on_overflow */
 199          sh_elf_ignore_reloc,   /* special_function */
 200          "R_SH_DIR8BP",         /* name */
 201          false,                 /* partial_inplace */
 202          0,                     /* src_mask */
 203          0xff,                  /* dst_mask */
 204          true),                 /* pcrel_offset */
 205
 206   /* 8 bit GBR relative divided by 2.  FIXME: This only makes sense if
 207      we have some special symbol for the GBR relative area, and that
 208      is not implemented.  */
 209   HOWTO (R_SH_DIR8W,            /* type */
 210          1,                     /* rightshift */
 211          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 212          8,                     /* bitsize */
 213          false,                 /* pc_relative */
 214          0,                     /* bitpos */
 215          complain_overflow_unsigned, /* complain_on_overflow */
 216          sh_elf_ignore_reloc,   /* special_function */
 217          "R_SH_DIR8W",          /* name */
 218          false,                 /* partial_inplace */
 219          0,                     /* src_mask */
 220          0xff,                  /* dst_mask */
 221          true),                 /* pcrel_offset */
 222
 223   /* 8 bit GBR relative divided by 4.  FIXME: This only makes sense if
 224      we have some special symbol for the GBR relative area, and that
 225      is not implemented.  */
 226   HOWTO (R_SH_DIR8L,            /* type */
 227          2,                     /* rightshift */
 228          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 229          8,                     /* bitsize */
 230          false,                 /* pc_relative */
 231          0,                     /* bitpos */
 232          complain_overflow_unsigned, /* complain_on_overflow */
 233          sh_elf_ignore_reloc,   /* special_function */
 234          "R_SH_DIR8L",          /* name */
 235          false,                 /* partial_inplace */
 236          0,                     /* src_mask */
 237          0xff,                  /* dst_mask */
 238          true),                 /* pcrel_offset */
 239
 240   EMPTY_HOWTO (10),
 241   EMPTY_HOWTO (11),
 242   EMPTY_HOWTO (12),
 243   EMPTY_HOWTO (13),
 244   EMPTY_HOWTO (14),
 245   EMPTY_HOWTO (15),
 246   EMPTY_HOWTO (16),
 247   EMPTY_HOWTO (17),
 248   EMPTY_HOWTO (18),
 249   EMPTY_HOWTO (19),
 250   EMPTY_HOWTO (20),
 251   EMPTY_HOWTO (21),
 252   EMPTY_HOWTO (22),
 253   EMPTY_HOWTO (23),
 254   EMPTY_HOWTO (24),
 255
 256   /* The remaining relocs are a GNU extension used for relaxing.  The
 257      final pass of the linker never needs to do anything with any of
 258      these relocs.  Any required operations are handled by the
 259      relaxation code.  */
 260
 261   /* A 16 bit switch table entry.  This is generated for an expression
 262      such as ``.word L1 - L2''.  The offset holds the difference
 263      between the reloc address and L2.  */
 264   HOWTO (R_SH_SWITCH16,         /* type */
 265          0,                     /* rightshift */
 266          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 267          16,                    /* bitsize */
 268          false,                 /* pc_relative */
 269          0,                     /* bitpos */
 270          complain_overflow_unsigned, /* complain_on_overflow */
 271          sh_elf_ignore_reloc,   /* special_function */
 272          "R_SH_SWITCH16",       /* name */
 273          false,                 /* partial_inplace */
 274          0,                     /* src_mask */
 275          0,                     /* dst_mask */
 276          true),                 /* pcrel_offset */
 277
 278   /* A 32 bit switch table entry.  This is generated for an expression
 279      such as ``.long L1 - L2''.  The offset holds the difference
 280      between the reloc address and L2.  */
 281   HOWTO (R_SH_SWITCH32,         /* type */
 282          0,                     /* rightshift */
 283          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 284          32,                    /* bitsize */
 285          false,                 /* pc_relative */
 286          0,                     /* bitpos */
 287          complain_overflow_unsigned, /* complain_on_overflow */
 288          sh_elf_ignore_reloc,   /* special_function */
 289          "R_SH_SWITCH32",       /* name */
 290          false,                 /* partial_inplace */
 291          0,                     /* src_mask */
 292          0,                     /* dst_mask */
 293          true),                 /* pcrel_offset */
 294
 295   /* Indicates a .uses pseudo-op.  The compiler will generate .uses
 296      pseudo-ops when it finds a function call which can be relaxed.
 297      The offset field holds the PC relative offset to the instruction
 298      which loads the register used in the function call.  */
 299   HOWTO (R_SH_USES,             /* type */
 300          0,                     /* rightshift */
 301          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 302          0,                     /* bitsize */
 303          false,                 /* pc_relative */
 304          0,                     /* bitpos */
 305          complain_overflow_unsigned, /* complain_on_overflow */
 306          sh_elf_ignore_reloc,   /* special_function */
 307          "R_SH_USES",           /* name */
 308          false,                 /* partial_inplace */
 309          0,                     /* src_mask */
 310          0,                     /* dst_mask */
 311          true),                 /* pcrel_offset */
 312
 313   /* The assembler will generate this reloc for addresses referred to
 314      by the register loads associated with USES relocs.  The offset
 315      field holds the number of times the address is referenced in the
 316      object file.  */
 317   HOWTO (R_SH_COUNT,            /* type */
 318          0,                     /* rightshift */
 319          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 320          0,                     /* bitsize */
 321          false,                 /* pc_relative */
 322          0,                     /* bitpos */
 323          complain_overflow_unsigned, /* complain_on_overflow */
 324          sh_elf_ignore_reloc,   /* special_function */
 325          "R_SH_COUNT",          /* name */
 326          false,                 /* partial_inplace */
 327          0,                     /* src_mask */
 328          0,                     /* dst_mask */
 329          true),                 /* pcrel_offset */
 330
 331   /* Indicates an alignment statement.  The offset field is the power
 332      of 2 to which subsequent portions of the object file must be
 333      aligned.  */
 334   HOWTO (R_SH_ALIGN,            /* type */
 335          0,                     /* rightshift */
 336          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 337          0,                     /* bitsize */
 338          false,                 /* pc_relative */
 339          0,                     /* bitpos */
 340          complain_overflow_unsigned, /* complain_on_overflow */
 341          sh_elf_ignore_reloc,   /* special_function */
 342          "R_SH_ALIGN",  /* name */
 343          false,                 /* partial_inplace */
 344          0,                     /* src_mask */
 345          0,                     /* dst_mask */
 346          true),                 /* pcrel_offset */
 347
 348   /* The assembler will generate this reloc before a block of
 349      instructions.  A section should be processed as assumining it
 350      contains data, unless this reloc is seen.  */
 351   HOWTO (R_SH_CODE,             /* type */
 352          0,                     /* rightshift */
 353          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 354          0,                     /* bitsize */
 355          false,                 /* pc_relative */
 356          0,                     /* bitpos */
 357          complain_overflow_unsigned, /* complain_on_overflow */
 358          sh_elf_ignore_reloc,   /* special_function */
 359          "R_SH_CODE",           /* name */
 360          false,                 /* partial_inplace */
 361          0,                     /* src_mask */
 362          0,                     /* dst_mask */
 363          true),                 /* pcrel_offset */
 364
 365   /* The assembler will generate this reloc after a block of
 366      instructions when it sees data that is not instructions.  */
 367   HOWTO (R_SH_DATA,             /* type */
 368          0,                     /* rightshift */
 369          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 370          0,                     /* bitsize */
 371          false,                 /* pc_relative */
 372          0,                     /* bitpos */
 373          complain_overflow_unsigned, /* complain_on_overflow */
 374          sh_elf_ignore_reloc,   /* special_function */
 375          "R_SH_DATA",           /* name */
 376          false,                 /* partial_inplace */
 377          0,                     /* src_mask */
 378          0,                     /* dst_mask */
 379          true),                 /* pcrel_offset */
 380
 381   /* The assembler generates this reloc for each label within a block
 382      of instructions.  This permits the linker to avoid swapping
 383      instructions which are the targets of branches.  */
 384   HOWTO (R_SH_LABEL,            /* type */
 385          0,                     /* rightshift */
 386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          0,                     /* bitsize */
 388          false,                 /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_unsigned, /* complain_on_overflow */
 391          sh_elf_ignore_reloc,   /* special_function */
 392          "R_SH_LABEL",          /* name */
 393          false,                 /* partial_inplace */
 394          0,                     /* src_mask */
 395          0,                     /* dst_mask */
 396          true),                 /* pcrel_offset */
 397
 398   /* An 8 bit switch table entry.  This is generated for an expression
 399      such as ``.word L1 - L2''.  The offset holds the difference
 400      between the reloc address and L2.  */
 401   HOWTO (R_SH_SWITCH8,          /* type */
 402          0,                     /* rightshift */
 403          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          8,                     /* bitsize */
 405          false,                 /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_unsigned, /* complain_on_overflow */
 408          sh_elf_ignore_reloc,   /* special_function */
 409          "R_SH_SWITCH8",        /* name */
 410          false,                 /* partial_inplace */
 411          0,                     /* src_mask */
 412          0,                     /* dst_mask */
 413          true),                 /* pcrel_offset */
 414
 415   /* GNU extension to record C++ vtable hierarchy */
 416   HOWTO (R_SH_GNU_VTINHERIT, /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          0,                     /* bitsize */
 420          false,                 /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_dont, /* complain_on_overflow */
 423          NULL,                  /* special_function */
 424          "R_SH_GNU_VTINHERIT", /* name */
 425          false,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0,                     /* dst_mask */
 428          false),                /* pcrel_offset */
 429
 430   /* GNU extension to record C++ vtable member usage */
 431   HOWTO (R_SH_GNU_VTENTRY,     /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          0,                     /* bitsize */
 435          false,                 /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_dont, /* complain_on_overflow */
 438          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 439          "R_SH_GNU_VTENTRY",   /* name */
 440          false,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0,                     /* dst_mask */
 443          false),                /* pcrel_offset */
 444
 445   /* 8 bit PC relative divided by 2 - but specified in a very odd way.  */
 446   HOWTO (R_SH_LOOP_START,       /* type */
 447          1,                     /* rightshift */
 448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 449          8,                     /* bitsize */
 450          false,                 /* pc_relative */
 451          0,                     /* bitpos */
 452          complain_overflow_signed, /* complain_on_overflow */
 453          sh_elf_ignore_reloc,   /* special_function */
 454          "R_SH_LOOP_START",     /* name */
 455          true,                  /* partial_inplace */
 456          0xff,                  /* src_mask */
 457          0xff,                  /* dst_mask */
 458          true),                 /* pcrel_offset */
 459
 460   /* 8 bit PC relative divided by 2 - but specified in a very odd way.  */
 461   HOWTO (R_SH_LOOP_END,         /* type */
 462          1,                     /* rightshift */
 463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 464          8,                     /* bitsize */
 465          false,                 /* pc_relative */
 466          0,                     /* bitpos */
 467          complain_overflow_signed, /* complain_on_overflow */
 468          sh_elf_ignore_reloc,   /* special_function */
 469          "R_SH_LOOP_END",       /* name */
 470          true,                  /* partial_inplace */
 471          0xff,                  /* src_mask */
 472          0xff,                  /* dst_mask */
 473          true),                 /* pcrel_offset */
 474
 475   EMPTY_HOWTO (38),
 476   EMPTY_HOWTO (39),
 477   EMPTY_HOWTO (40),
 478   EMPTY_HOWTO (41),
 479   EMPTY_HOWTO (42),
 480   EMPTY_HOWTO (43),
 481   EMPTY_HOWTO (44),
 482   EMPTY_HOWTO (45),
 483   EMPTY_HOWTO (46),
 484   EMPTY_HOWTO (47),
 485   EMPTY_HOWTO (48),
 486   EMPTY_HOWTO (49),
 487   EMPTY_HOWTO (50),
 488   EMPTY_HOWTO (51),
 489   EMPTY_HOWTO (52),
 490   EMPTY_HOWTO (53),
 491   EMPTY_HOWTO (54),
 492   EMPTY_HOWTO (55),
 493   EMPTY_HOWTO (56),
 494   EMPTY_HOWTO (57),
 495   EMPTY_HOWTO (58),
 496   EMPTY_HOWTO (59),
 497   EMPTY_HOWTO (60),
 498   EMPTY_HOWTO (61),
 499   EMPTY_HOWTO (62),
 500   EMPTY_HOWTO (63),
 501   EMPTY_HOWTO (64),
 502   EMPTY_HOWTO (65),
 503   EMPTY_HOWTO (66),
 504   EMPTY_HOWTO (67),
 505   EMPTY_HOWTO (68),
 506   EMPTY_HOWTO (69),
 507   EMPTY_HOWTO (70),
 508   EMPTY_HOWTO (71),
 509   EMPTY_HOWTO (72),
 510   EMPTY_HOWTO (73),
 511   EMPTY_HOWTO (74),
 512   EMPTY_HOWTO (75),
 513   EMPTY_HOWTO (76),
 514   EMPTY_HOWTO (77),
 515   EMPTY_HOWTO (78),
 516   EMPTY_HOWTO (79),
 517   EMPTY_HOWTO (80),
 518   EMPTY_HOWTO (81),
 519   EMPTY_HOWTO (82),
 520   EMPTY_HOWTO (83),
 521   EMPTY_HOWTO (84),
 522   EMPTY_HOWTO (85),
 523   EMPTY_HOWTO (86),
 524   EMPTY_HOWTO (87),
 525   EMPTY_HOWTO (88),
 526   EMPTY_HOWTO (89),
 527   EMPTY_HOWTO (90),
 528   EMPTY_HOWTO (91),
 529   EMPTY_HOWTO (92),
 530   EMPTY_HOWTO (93),
 531   EMPTY_HOWTO (94),
 532   EMPTY_HOWTO (95),
 533   EMPTY_HOWTO (96),
 534   EMPTY_HOWTO (97),
 535   EMPTY_HOWTO (98),
 536   EMPTY_HOWTO (99),
 537   EMPTY_HOWTO (100),
 538   EMPTY_HOWTO (101),
 539   EMPTY_HOWTO (102),
 540   EMPTY_HOWTO (103),
 541   EMPTY_HOWTO (104),
 542   EMPTY_HOWTO (105),
 543   EMPTY_HOWTO (106),
 544   EMPTY_HOWTO (107),
 545   EMPTY_HOWTO (108),
 546   EMPTY_HOWTO (109),
 547   EMPTY_HOWTO (110),
 548   EMPTY_HOWTO (111),
 549   EMPTY_HOWTO (112),
 550   EMPTY_HOWTO (113),
 551   EMPTY_HOWTO (114),
 552   EMPTY_HOWTO (115),
 553   EMPTY_HOWTO (116),
 554   EMPTY_HOWTO (117),
 555   EMPTY_HOWTO (118),
 556   EMPTY_HOWTO (119),
 557   EMPTY_HOWTO (120),
 558   EMPTY_HOWTO (121),
 559   EMPTY_HOWTO (122),
 560   EMPTY_HOWTO (123),
 561   EMPTY_HOWTO (124),
 562   EMPTY_HOWTO (125),
 563   EMPTY_HOWTO (126),
 564   EMPTY_HOWTO (127),
 565   EMPTY_HOWTO (128),
 566   EMPTY_HOWTO (129),
 567   EMPTY_HOWTO (130),
 568   EMPTY_HOWTO (131),
 569   EMPTY_HOWTO (132),
 570   EMPTY_HOWTO (133),
 571   EMPTY_HOWTO (134),
 572   EMPTY_HOWTO (135),
 573   EMPTY_HOWTO (136),
 574   EMPTY_HOWTO (137),
 575   EMPTY_HOWTO (138),
 576   EMPTY_HOWTO (139),
 577   EMPTY_HOWTO (140),
 578   EMPTY_HOWTO (141),
 579   EMPTY_HOWTO (142),
 580   EMPTY_HOWTO (143),
 581   EMPTY_HOWTO (144),
 582   EMPTY_HOWTO (145),
 583   EMPTY_HOWTO (146),
 584   EMPTY_HOWTO (147),
 585   EMPTY_HOWTO (148),
 586   EMPTY_HOWTO (149),
 587   EMPTY_HOWTO (150),
 588   EMPTY_HOWTO (151),
 589   EMPTY_HOWTO (152),
 590   EMPTY_HOWTO (153),
 591   EMPTY_HOWTO (154),
 592   EMPTY_HOWTO (155),
 593   EMPTY_HOWTO (156),
 594   EMPTY_HOWTO (157),
 595   EMPTY_HOWTO (158),
 596   EMPTY_HOWTO (159),
 597
 598   HOWTO (R_SH_GOT32,            /* type */
 599          0,                     /* rightshift */
 600          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 601          32,                    /* bitsize */
 602          false,                 /* pc_relative */
 603          0,                     /* bitpos */
 604          complain_overflow_bitfield, /* complain_on_overflow */
 605          bfd_elf_generic_reloc, /* */
 606          "R_SH_GOT32",          /* name */
 607          true,                  /* partial_inplace */
 608          0xffffffff,            /* src_mask */
 609          0xffffffff,            /* dst_mask */
 610          false),                /* pcrel_offset */
 611
 612   HOWTO (R_SH_PLT32,            /* type */
 613          0,                     /* rightshift */
 614          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 615          32,                    /* bitsize */
 616          true,                  /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_bitfield, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* */
 620          "R_SH_PLT32",          /* name */
 621          true,                  /* partial_inplace */
 622          0xffffffff,            /* src_mask */
 623          0xffffffff,            /* dst_mask */
 624          true),                 /* pcrel_offset */
 625
 626   HOWTO (R_SH_COPY,             /* type */
 627          0,                     /* rightshift */
 628          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 629          32,                    /* bitsize */
 630          false,                 /* pc_relative */
 631          0,                     /* bitpos */
 632          complain_overflow_bitfield, /* complain_on_overflow */
 633          bfd_elf_generic_reloc, /* */
 634          "R_SH_COPY",           /* name */
 635          true,                  /* partial_inplace */
 636          0xffffffff,            /* src_mask */
 637          0xffffffff,            /* dst_mask */
 638          false),                /* pcrel_offset */
 639
 640   HOWTO (R_SH_GLOB_DAT,         /* type */
 641          0,                     /* rightshift */
 642          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 643          32,                    /* bitsize */
 644          false,                 /* pc_relative */
 645          0,                     /* bitpos */
 646          complain_overflow_bitfield, /* complain_on_overflow */
 647          bfd_elf_generic_reloc, /* */
 648          "R_SH_GLOB_DAT",       /* name */
 649          true,                  /* partial_inplace */
 650          0xffffffff,            /* src_mask */
 651          0xffffffff,            /* dst_mask */
 652          false),                /* pcrel_offset */
 653
 654   HOWTO (R_SH_JMP_SLOT,         /* type */
 655          0,                     /* rightshift */
 656          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 657          32,                    /* bitsize */
 658          false,                 /* pc_relative */
 659          0,                     /* bitpos */
 660          complain_overflow_bitfield, /* complain_on_overflow */
 661          bfd_elf_generic_reloc, /* */
 662          "R_SH_JMP_SLOT",       /* name */
 663          true,                  /* partial_inplace */
 664          0xffffffff,            /* src_mask */
 665          0xffffffff,            /* dst_mask */
 666          false),                /* pcrel_offset */
 667
 668   HOWTO (R_SH_RELATIVE,         /* type */
 669          0,                     /* rightshift */
 670          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 671          32,                    /* bitsize */
 672          false,                 /* pc_relative */
 673          0,                     /* bitpos */
 674          complain_overflow_bitfield, /* complain_on_overflow */
 675          bfd_elf_generic_reloc, /* */
 676          "R_SH_RELATIVE",       /* name */
 677          true,                  /* partial_inplace */
 678          0xffffffff,            /* src_mask */
 679          0xffffffff,            /* dst_mask */
 680          false),                /* pcrel_offset */
 681
 682   HOWTO (R_SH_GOTOFF,           /* type */
 683          0,                     /* rightshift */
 684          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 685          32,                    /* bitsize */
 686          false,                 /* pc_relative */
 687          0,                     /* bitpos */
 688          complain_overflow_bitfield, /* complain_on_overflow */
 689          bfd_elf_generic_reloc, /* */
 690          "R_SH_GOTOFF",         /* name */
 691          true,                  /* partial_inplace */
 692          0xffffffff,            /* src_mask */
 693          0xffffffff,            /* dst_mask */
 694          false),                /* pcrel_offset */
 695
 696   HOWTO (R_SH_GOTPC,            /* type */
 697          0,                     /* rightshift */
 698          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 699          32,                    /* bitsize */
 700          true,                  /* pc_relative */
 701          0,                     /* bitpos */
 702          complain_overflow_bitfield, /* complain_on_overflow */
 703          bfd_elf_generic_reloc, /* */
 704          "R_SH_GOTPC",          /* name */
 705          true,                  /* partial_inplace */
 706          0xffffffff,            /* src_mask */
 707          0xffffffff,            /* dst_mask */
 708          true),                 /* pcrel_offset */
 709
 710 };
 711
 712 static bfd_reloc_status_type
 713 sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr,
 714                    symbol_section, start, end)
 715      int r_type ATTRIBUTE_UNUSED;
 716      bfd *input_bfd;
 717      asection *input_section;
 718      bfd_byte *contents;
 719      bfd_vma addr;
 720      asection *symbol_section;
 721      bfd_vma start, end;
 722 {
 723   static bfd_vma last_addr;
 724   static asection *last_symbol_section;
 725   bfd_byte *free_contents = NULL;
 726   bfd_byte *start_ptr, *ptr, *last_ptr;
 727   int diff, cum_diff;
 728   bfd_signed_vma x;
 729   int insn;
 730
 731   /* Sanity check the address.  */
 732   if (addr > input_section->_raw_size)
 733     return bfd_reloc_outofrange;
 734
 735   /* We require the start and end relocations to be processed consecutively -
 736      although we allow then to be processed forwards or backwards.  */
 737   if (! last_addr)
 738     {
 739       last_addr = addr;
 740       last_symbol_section = symbol_section;
 741       return bfd_reloc_ok;
 742     }
 743   if (last_addr != addr)
 744     abort ();
 745   last_addr = 0;
 746
 747   if (! symbol_section || last_symbol_section != symbol_section || end < start)
 748     return bfd_reloc_outofrange;
 749
 750   /* Get the symbol_section contents.  */
 751   if (symbol_section != input_section)
 752     {
 753       if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
 754         contents = elf_section_data (symbol_section)->this_hdr.contents;
 755       else
 756         {
 757           free_contents = contents
 758             = (bfd_byte *) bfd_malloc (symbol_section->_raw_size);
 759           if (contents == NULL)
 760             return bfd_reloc_outofrange;
 761           if (! bfd_get_section_contents (input_bfd, symbol_section, contents,
 762                                           (file_ptr) 0,
 763                                           symbol_section->_raw_size))
 764             {
 765               free (contents);
 766               return bfd_reloc_outofrange;
 767             }
 768         }
 769     }
 770 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
 771   start_ptr = contents + start;
 772   for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
 773     {
 774       for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
 775         ptr -= 2;
 776       ptr += 2;
 777       diff = (last_ptr - ptr) >> 1;
 778       cum_diff += diff & 1;
 779       cum_diff += diff;
 780     }
 781   /* Calculate the start / end values to load into rs / re minus four -
 782      so that will cancel out the four we would otherwise have to add to
 783      addr to get the value to subtract in order to get relative addressing.  */
 784   if (cum_diff >= 0)
 785     {
 786       start -= 4;
 787       end = (ptr + cum_diff * 2) - contents;
 788     }
 789   else
 790     {
 791       bfd_vma start0 = start - 4;
 792
 793       while (start0 && IS_PPI (contents + start0))
 794         start0 -= 2;
 795       start0 = start - 2 - ((start - start0) & 2);
 796       start = start0 - cum_diff - 2;
 797       end = start0;
 798     }
 799
 800   if (free_contents)
 801     free (free_contents);
 802
 803   insn = bfd_get_16 (input_bfd, contents + addr);
 804
 805   x = (insn & 0x200 ? end : start) - addr;
 806   if (input_section != symbol_section)
 807     x += ((symbol_section->output_section->vma + symbol_section->output_offset)
 808           - (input_section->output_section->vma
 809              + input_section->output_offset));
 810   x >>= 1;
 811   if (x < -128 || x > 127)
 812     return bfd_reloc_overflow;
 813
 814   x = (insn & ~0xff) | (x & 0xff);
 815   bfd_put_16 (input_bfd, x, contents + addr);
 816
 817   return bfd_reloc_ok;
 818 }
 819
 820 /* This function is used for normal relocs.  This used to be like the COFF
 821    function, and is almost certainly incorrect for other ELF targets.  */
 822
 823 static bfd_reloc_status_type
 824 sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
 825               error_message)
 826      bfd *abfd;
 827      arelent *reloc_entry;
 828      asymbol *symbol_in;
 829      PTR data;
 830      asection *input_section;
 831      bfd *output_bfd;
 832      char **error_message ATTRIBUTE_UNUSED;
 833 {
 834   unsigned long insn;
 835   bfd_vma sym_value;
 836   enum elf_sh_reloc_type r_type;
 837   bfd_vma addr = reloc_entry->address;
 838   bfd_byte *hit_data = addr + (bfd_byte *) data;
 839
 840   r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
 841
 842   if (output_bfd != NULL)
 843     {
 844       /* Partial linking--do nothing.  */
 845       reloc_entry->address += input_section->output_offset;
 846       return bfd_reloc_ok;
 847     }
 848
 849   /* Almost all relocs have to do with relaxing.  If any work must be
 850      done for them, it has been done in sh_relax_section.  */
 851   if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
 852     return bfd_reloc_ok;
 853
 854   if (symbol_in != NULL
 855       && bfd_is_und_section (symbol_in->section))
 856     return bfd_reloc_undefined;
 857
 858   if (bfd_is_com_section (symbol_in->section))
 859     sym_value = 0;
 860   else
 861     sym_value = (symbol_in->value +
 862                  symbol_in->section->output_section->vma +
 863                  symbol_in->section->output_offset);
 864
 865   switch (r_type)
 866     {
 867     case R_SH_DIR32:
 868       insn = bfd_get_32 (abfd, hit_data);
 869       insn += sym_value + reloc_entry->addend;
 870       bfd_put_32 (abfd, insn, hit_data);
 871       break;
 872     case R_SH_IND12W:
 873       insn = bfd_get_16 (abfd, hit_data);
 874       sym_value += reloc_entry->addend;
 875       sym_value -= (input_section->output_section->vma
 876                     + input_section->output_offset
 877                     + addr
 878                     + 4);
 879       sym_value += (insn & 0xfff) << 1;
 880       if (insn & 0x800)
 881         sym_value -= 0x1000;
 882       insn = (insn & 0xf000) | (sym_value & 0xfff);
 883       bfd_put_16 (abfd, insn, hit_data);
 884       if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
 885         return bfd_reloc_overflow;
 886       break;
 887     default:
 888       abort ();
 889       break;
 890     }
 891
 892   return bfd_reloc_ok;
 893 }
 894
 895 /* This function is used for relocs which are only used for relaxing,
 896    which the linker should otherwise ignore.  */
 897
 898 static bfd_reloc_status_type
 899 sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
 900                      output_bfd, error_message)
 901      bfd *abfd ATTRIBUTE_UNUSED;
 902      arelent *reloc_entry;
 903      asymbol *symbol ATTRIBUTE_UNUSED;
 904      PTR data ATTRIBUTE_UNUSED;
 905      asection *input_section;
 906      bfd *output_bfd;
 907      char **error_message ATTRIBUTE_UNUSED;
 908 {
 909   if (output_bfd != NULL)
 910     reloc_entry->address += input_section->output_offset;
 911   return bfd_reloc_ok;
 912 }
 913
 914 /* This structure is used to map BFD reloc codes to SH ELF relocs.  */
 915
 916 struct elf_reloc_map
 917 {
 918   bfd_reloc_code_real_type bfd_reloc_val;
 919   unsigned char elf_reloc_val;
 920 };
 921
 922 /* An array mapping BFD reloc codes to SH ELF relocs.  */
 923
 924 static const struct elf_reloc_map sh_reloc_map[] =
 925 {
 926   { BFD_RELOC_NONE, R_SH_NONE },
 927   { BFD_RELOC_32, R_SH_DIR32 },
 928   { BFD_RELOC_CTOR, R_SH_DIR32 },
 929   { BFD_RELOC_32_PCREL, R_SH_REL32 },
 930   { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
 931   { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
 932   { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
 933   { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
 934   { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
 935   { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
 936   { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
 937   { BFD_RELOC_SH_USES, R_SH_USES },
 938   { BFD_RELOC_SH_COUNT, R_SH_COUNT },
 939   { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
 940   { BFD_RELOC_SH_CODE, R_SH_CODE },
 941   { BFD_RELOC_SH_DATA, R_SH_DATA },
 942   { BFD_RELOC_SH_LABEL, R_SH_LABEL },
 943   { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
 944   { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
 945   { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
 946   { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
 947   { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
 948   { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
 949   { BFD_RELOC_SH_COPY, R_SH_COPY },
 950   { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
 951   { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
 952   { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
 953   { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
 954   { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
 955 };
 956
 957 /* Given a BFD reloc code, return the howto structure for the
 958    corresponding SH ELf reloc.  */
 959
 960 static reloc_howto_type *
 961 sh_elf_reloc_type_lookup (abfd, code)
 962      bfd *abfd ATTRIBUTE_UNUSED;
 963      bfd_reloc_code_real_type code;
 964 {
 965   unsigned int i;
 966
 967   for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
 968     {
 969       if (sh_reloc_map[i].bfd_reloc_val == code)
 970         return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
 971     }
 972
 973   return NULL;
 974 }
 975
 976 /* Given an ELF reloc, fill in the howto field of a relent.  */
 977
 978 static void
 979 sh_elf_info_to_howto (abfd, cache_ptr, dst)
 980      bfd *abfd ATTRIBUTE_UNUSED;
 981      arelent *cache_ptr;
 982      Elf_Internal_Rela *dst;
 983 {
 984   unsigned int r;
 985
 986   r = ELF32_R_TYPE (dst->r_info);
 987
 988   BFD_ASSERT (r < (unsigned int) R_SH_max);
 989   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
 990   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2);
 991
 992   cache_ptr->howto = &sh_elf_howto_table[r];
 993 }
 994 \f
 995 /* This function handles relaxing for SH ELF.  See the corresponding
 996    function in coff-sh.c for a description of what this does.  FIXME:
 997    There is a lot of duplication here between this code and the COFF
 998    specific code.  The format of relocs and symbols is wound deeply
 999    into this code, but it would still be better if the duplication
1000    could be eliminated somehow.  Note in particular that although both
1001    functions use symbols like R_SH_CODE, those symbols have different
1002    values; in coff-sh.c they come from include/coff/sh.h, whereas here
1003    they come from enum elf_sh_reloc_type in include/elf/sh.h.  */
1004
1005 static boolean
1006 sh_elf_relax_section (abfd, sec, link_info, again)
1007      bfd *abfd;
1008      asection *sec;
1009      struct bfd_link_info *link_info;
1010      boolean *again;
1011 {
1012   Elf_Internal_Shdr *symtab_hdr;
1013   Elf_Internal_Rela *internal_relocs;
1014   Elf_Internal_Rela *free_relocs = NULL;
1015   boolean have_code;
1016   Elf_Internal_Rela *irel, *irelend;
1017   bfd_byte *contents = NULL;
1018   bfd_byte *free_contents = NULL;
1019   Elf32_External_Sym *extsyms = NULL;
1020   Elf32_External_Sym *free_extsyms = NULL;
1021
1022   *again = false;
1023
1024   if (link_info->relocateable
1025       || (sec->flags & SEC_RELOC) == 0
1026       || sec->reloc_count == 0)
1027     return true;
1028
1029   /* If this is the first time we have been called for this section,
1030      initialize the cooked size.  */
1031   if (sec->_cooked_size == 0)
1032     sec->_cooked_size = sec->_raw_size;
1033
1034   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1035
1036   internal_relocs = (_bfd_elf32_link_read_relocs
1037                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1038                       link_info->keep_memory));
1039   if (internal_relocs == NULL)
1040     goto error_return;
1041   if (! link_info->keep_memory)
1042     free_relocs = internal_relocs;
1043
1044   have_code = false;
1045
1046   irelend = internal_relocs + sec->reloc_count;
1047   for (irel = internal_relocs; irel < irelend; irel++)
1048     {
1049       bfd_vma laddr, paddr, symval;
1050       unsigned short insn;
1051       Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
1052       bfd_signed_vma foff;
1053
1054       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
1055         have_code = true;
1056
1057       if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
1058         continue;
1059
1060       /* Get the section contents.  */
1061       if (contents == NULL)
1062         {
1063           if (elf_section_data (sec)->this_hdr.contents != NULL)
1064             contents = elf_section_data (sec)->this_hdr.contents;
1065           else
1066             {
1067               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1068               if (contents == NULL)
1069                 goto error_return;
1070               free_contents = contents;
1071
1072               if (! bfd_get_section_contents (abfd, sec, contents,
1073                                               (file_ptr) 0, sec->_raw_size))
1074                 goto error_return;
1075             }
1076         }
1077
1078       /* The r_addend field of the R_SH_USES reloc will point us to
1079          the register load.  The 4 is because the r_addend field is
1080          computed as though it were a jump offset, which are based
1081          from 4 bytes after the jump instruction.  */
1082       laddr = irel->r_offset + 4 + irel->r_addend;
1083       if (laddr >= sec->_raw_size)
1084         {
1085           (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
1086                                  bfd_get_filename (abfd),
1087                                  (unsigned long) irel->r_offset);
1088           continue;
1089         }
1090       insn = bfd_get_16 (abfd, contents + laddr);
1091
1092       /* If the instruction is not mov.l NN,rN, we don't know what to
1093          do.  */
1094       if ((insn & 0xf000) != 0xd000)
1095         {
1096           ((*_bfd_error_handler)
1097            (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
1098             bfd_get_filename (abfd), (unsigned long) irel->r_offset, insn));
1099           continue;
1100         }
1101
1102       /* Get the address from which the register is being loaded.  The
1103          displacement in the mov.l instruction is quadrupled.  It is a
1104          displacement from four bytes after the movl instruction, but,
1105          before adding in the PC address, two least significant bits
1106          of the PC are cleared.  We assume that the section is aligned
1107          on a four byte boundary.  */
1108       paddr = insn & 0xff;
1109       paddr *= 4;
1110       paddr += (laddr + 4) & ~3;
1111       if (paddr >= sec->_raw_size)
1112         {
1113           ((*_bfd_error_handler)
1114            (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
1115             bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1116           continue;
1117         }
1118
1119       /* Get the reloc for the address from which the register is
1120          being loaded.  This reloc will tell us which function is
1121          actually being called.  */
1122       for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
1123         if (irelfn->r_offset == paddr
1124             && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
1125           break;
1126       if (irelfn >= irelend)
1127         {
1128           ((*_bfd_error_handler)
1129            (_("%s: 0x%lx: warning: could not find expected reloc"),
1130             bfd_get_filename (abfd), (unsigned long) paddr));
1131           continue;
1132         }
1133
1134       /* Read this BFD's symbols if we haven't done so already.  */
1135       if (extsyms == NULL)
1136         {
1137           if (symtab_hdr->contents != NULL)
1138             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1139           else
1140             {
1141               extsyms = ((Elf32_External_Sym *)
1142                          bfd_malloc (symtab_hdr->sh_size));
1143               if (extsyms == NULL)
1144                 goto error_return;
1145               free_extsyms = extsyms;
1146               if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1147                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1148                       != symtab_hdr->sh_size))
1149                 goto error_return;
1150             }
1151         }
1152
1153       /* Get the value of the symbol referred to by the reloc.  */
1154       if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
1155         {
1156           Elf_Internal_Sym isym;
1157
1158           /* A local symbol.  */
1159           bfd_elf32_swap_symbol_in (abfd,
1160                                     extsyms + ELF32_R_SYM (irelfn->r_info),
1161                                     &isym);
1162
1163           if (isym.st_shndx != _bfd_elf_section_from_bfd_section (abfd, sec))
1164             {
1165               ((*_bfd_error_handler)
1166                (_("%s: 0x%lx: warning: symbol in unexpected section"),
1167                 bfd_get_filename (abfd), (unsigned long) paddr));
1168               continue;
1169             }
1170
1171           symval = (isym.st_value
1172                     + sec->output_section->vma
1173                     + sec->output_offset);
1174         }
1175       else
1176         {
1177           unsigned long indx;
1178           struct elf_link_hash_entry *h;
1179
1180           indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
1181           h = elf_sym_hashes (abfd)[indx];
1182           BFD_ASSERT (h != NULL);
1183           if (h->root.type != bfd_link_hash_defined
1184               && h->root.type != bfd_link_hash_defweak)
1185             {
1186               /* This appears to be a reference to an undefined
1187                  symbol.  Just ignore it--it will be caught by the
1188                  regular reloc processing.  */
1189               continue;
1190             }
1191
1192           symval = (h->root.u.def.value
1193                     + h->root.u.def.section->output_section->vma
1194                     + h->root.u.def.section->output_offset);
1195         }
1196
1197       symval += bfd_get_32 (abfd, contents + paddr);
1198
1199       /* See if this function call can be shortened.  */
1200       foff = (symval
1201               - (irel->r_offset
1202                  + sec->output_section->vma
1203                  + sec->output_offset
1204                  + 4));
1205       if (foff < -0x1000 || foff >= 0x1000)
1206         {
1207           /* After all that work, we can't shorten this function call.  */
1208           continue;
1209         }
1210
1211       /* Shorten the function call.  */
1212
1213       /* For simplicity of coding, we are going to modify the section
1214          contents, the section relocs, and the BFD symbol table.  We
1215          must tell the rest of the code not to free up this
1216          information.  It would be possible to instead create a table
1217          of changes which have to be made, as is done in coff-mips.c;
1218          that would be more work, but would require less memory when
1219          the linker is run.  */
1220
1221       elf_section_data (sec)->relocs = internal_relocs;
1222       free_relocs = NULL;
1223
1224       elf_section_data (sec)->this_hdr.contents = contents;
1225       free_contents = NULL;
1226
1227       symtab_hdr->contents = (bfd_byte *) extsyms;
1228       free_extsyms = NULL;
1229
1230       /* Replace the jsr with a bsr.  */
1231
1232       /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
1233          replace the jsr with a bsr.  */
1234       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
1235       if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
1236         {
1237           /* If this needs to be changed because of future relaxing,
1238              it will be handled here like other internal IND12W
1239              relocs.  */
1240           bfd_put_16 (abfd,
1241                       0xb000 | ((foff >> 1) & 0xfff),
1242                       contents + irel->r_offset);
1243         }
1244       else
1245         {
1246           /* We can't fully resolve this yet, because the external
1247              symbol value may be changed by future relaxing.  We let
1248              the final link phase handle it.  */
1249           bfd_put_16 (abfd, 0xb000, contents + irel->r_offset);
1250         }
1251
1252       /* See if there is another R_SH_USES reloc referring to the same
1253          register load.  */
1254       for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
1255         if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
1256             && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
1257           break;
1258       if (irelscan < irelend)
1259         {
1260           /* Some other function call depends upon this register load,
1261              and we have not yet converted that function call.
1262              Indeed, we may never be able to convert it.  There is
1263              nothing else we can do at this point.  */
1264           continue;
1265         }
1266
1267       /* Look for a R_SH_COUNT reloc on the location where the
1268          function address is stored.  Do this before deleting any
1269          bytes, to avoid confusion about the address.  */
1270       for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
1271         if (irelcount->r_offset == paddr
1272             && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
1273           break;
1274
1275       /* Delete the register load.  */
1276       if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
1277         goto error_return;
1278
1279       /* That will change things, so, just in case it permits some
1280          other function call to come within range, we should relax
1281          again.  Note that this is not required, and it may be slow.  */
1282       *again = true;
1283
1284       /* Now check whether we got a COUNT reloc.  */
1285       if (irelcount >= irelend)
1286         {
1287           ((*_bfd_error_handler)
1288            (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
1289             bfd_get_filename (abfd), (unsigned long) paddr));
1290           continue;
1291         }
1292
1293       /* The number of uses is stored in the r_addend field.  We've
1294          just deleted one.  */
1295       if (irelcount->r_addend == 0)
1296         {
1297           ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
1298                                   bfd_get_filename (abfd),
1299                                   (unsigned long) paddr));
1300           continue;
1301         }
1302
1303       --irelcount->r_addend;
1304
1305       /* If there are no more uses, we can delete the address.  Reload
1306          the address from irelfn, in case it was changed by the
1307          previous call to sh_elf_relax_delete_bytes.  */
1308       if (irelcount->r_addend == 0)
1309         {
1310           if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
1311             goto error_return;
1312         }
1313
1314       /* We've done all we can with that function call.  */
1315     }
1316
1317   /* Look for load and store instructions that we can align on four
1318      byte boundaries.  */
1319   if (have_code)
1320     {
1321       boolean swapped;
1322
1323       /* Get the section contents.  */
1324       if (contents == NULL)
1325         {
1326           if (elf_section_data (sec)->this_hdr.contents != NULL)
1327             contents = elf_section_data (sec)->this_hdr.contents;
1328           else
1329             {
1330               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1331               if (contents == NULL)
1332                 goto error_return;
1333               free_contents = contents;
1334
1335               if (! bfd_get_section_contents (abfd, sec, contents,
1336                                               (file_ptr) 0, sec->_raw_size))
1337                 goto error_return;
1338             }
1339         }
1340
1341       if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
1342                                 &swapped))
1343         goto error_return;
1344
1345       if (swapped)
1346         {
1347           elf_section_data (sec)->relocs = internal_relocs;
1348           free_relocs = NULL;
1349
1350           elf_section_data (sec)->this_hdr.contents = contents;
1351           free_contents = NULL;
1352
1353           symtab_hdr->contents = (bfd_byte *) extsyms;
1354           free_extsyms = NULL;
1355         }
1356     }
1357
1358   if (free_relocs != NULL)
1359     {
1360       free (free_relocs);
1361       free_relocs = NULL;
1362     }
1363
1364   if (free_contents != NULL)
1365     {
1366       if (! link_info->keep_memory)
1367         free (free_contents);
1368       else
1369         {
1370           /* Cache the section contents for elf_link_input_bfd.  */
1371           elf_section_data (sec)->this_hdr.contents = contents;
1372         }
1373       free_contents = NULL;
1374     }
1375
1376   if (free_extsyms != NULL)
1377     {
1378       if (! link_info->keep_memory)
1379         free (free_extsyms);
1380       else
1381         {
1382           /* Cache the symbols for elf_link_input_bfd.  */
1383           symtab_hdr->contents = extsyms;
1384         }
1385       free_extsyms = NULL;
1386     }
1387
1388   return true;
1389
1390  error_return:
1391   if (free_relocs != NULL)
1392     free (free_relocs);
1393   if (free_contents != NULL)
1394     free (free_contents);
1395   if (free_extsyms != NULL)
1396     free (free_extsyms);
1397   return false;
1398 }
1399
1400 /* Delete some bytes from a section while relaxing.  FIXME: There is a
1401    lot of duplication between this function and sh_relax_delete_bytes
1402    in coff-sh.c.  */
1403
1404 static boolean
1405 sh_elf_relax_delete_bytes (abfd, sec, addr, count)
1406      bfd *abfd;
1407      asection *sec;
1408      bfd_vma addr;
1409      int count;
1410 {
1411   Elf_Internal_Shdr *symtab_hdr;
1412   Elf32_External_Sym *extsyms;
1413   int shndx, index;
1414   bfd_byte *contents;
1415   Elf_Internal_Rela *irel, *irelend;
1416   Elf_Internal_Rela *irelalign;
1417   bfd_vma toaddr;
1418   Elf32_External_Sym *esym, *esymend;
1419   struct elf_link_hash_entry *sym_hash;
1420   asection *o;
1421
1422   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1423   extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1424
1425   shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1426
1427   contents = elf_section_data (sec)->this_hdr.contents;
1428
1429   /* The deletion must stop at the next ALIGN reloc for an aligment
1430      power larger than the number of bytes we are deleting.  */
1431
1432   irelalign = NULL;
1433   toaddr = sec->_cooked_size;
1434
1435   irel = elf_section_data (sec)->relocs;
1436   irelend = irel + sec->reloc_count;
1437   for (; irel < irelend; irel++)
1438     {
1439       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1440           && irel->r_offset > addr
1441           && count < (1 << irel->r_addend))
1442         {
1443           irelalign = irel;
1444           toaddr = irel->r_offset;
1445           break;
1446         }
1447     }
1448
1449   /* Actually delete the bytes.  */
1450   memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1451   if (irelalign == NULL)
1452     sec->_cooked_size -= count;
1453   else
1454     {
1455       int i;
1456
1457 #define NOP_OPCODE (0x0009)
1458
1459       BFD_ASSERT ((count & 1) == 0);
1460       for (i = 0; i < count; i += 2)
1461         bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i);
1462     }
1463
1464   /* Adjust all the relocs.  */
1465   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1466     {
1467       bfd_vma nraddr, stop;
1468       bfd_vma start = 0;
1469       int insn = 0;
1470       Elf_Internal_Sym sym;
1471       int off, adjust, oinsn;
1472       bfd_signed_vma voff = 0;
1473       boolean overflow;
1474
1475       /* Get the new reloc address.  */
1476       nraddr = irel->r_offset;
1477       if ((irel->r_offset > addr
1478            && irel->r_offset < toaddr)
1479           || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1480               && irel->r_offset == toaddr))
1481         nraddr -= count;
1482
1483       /* See if this reloc was for the bytes we have deleted, in which
1484          case we no longer care about it.  Don't delete relocs which
1485          represent addresses, though.  */
1486       if (irel->r_offset >= addr
1487           && irel->r_offset < addr + count
1488           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
1489           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
1490           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
1491           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
1492         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1493                                      (int) R_SH_NONE);
1494
1495       /* If this is a PC relative reloc, see if the range it covers
1496          includes the bytes we have deleted.  */
1497       switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1498         {
1499         default:
1500           break;
1501
1502         case R_SH_DIR8WPN:
1503         case R_SH_IND12W:
1504         case R_SH_DIR8WPZ:
1505         case R_SH_DIR8WPL:
1506           start = irel->r_offset;
1507           insn = bfd_get_16 (abfd, contents + nraddr);
1508           break;
1509         }
1510
1511       switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1512         {
1513         default:
1514           start = stop = addr;
1515           break;
1516
1517         case R_SH_DIR32:
1518           /* If this reloc is against a symbol defined in this
1519              section, and the symbol will not be adjusted below, we
1520              must check the addend to see it will put the value in
1521              range to be adjusted, and hence must be changed.  */
1522           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1523             {
1524               bfd_elf32_swap_symbol_in (abfd,
1525                                         extsyms + ELF32_R_SYM (irel->r_info),
1526                                         &sym);
1527               if (sym.st_shndx == shndx
1528                   && (sym.st_value <= addr
1529                       || sym.st_value >= toaddr))
1530                 {
1531                   bfd_vma val;
1532
1533                   val = bfd_get_32 (abfd, contents + nraddr);
1534                   val += sym.st_value;
1535                   if (val > addr && val < toaddr)
1536                     bfd_put_32 (abfd, val - count, contents + nraddr);
1537                 }
1538             }
1539           start = stop = addr;
1540           break;
1541
1542         case R_SH_DIR8WPN:
1543           off = insn & 0xff;
1544           if (off & 0x80)
1545             off -= 0x100;
1546           stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1547           break;
1548
1549         case R_SH_IND12W:
1550           if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
1551             start = stop = addr;
1552           else
1553             {
1554               off = insn & 0xfff;
1555               if (off & 0x800)
1556                 off -= 0x1000;
1557               stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1558             }
1559           break;
1560
1561         case R_SH_DIR8WPZ:
1562           off = insn & 0xff;
1563           stop = start + 4 + off * 2;
1564           break;
1565
1566         case R_SH_DIR8WPL:
1567           off = insn & 0xff;
1568           stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
1569           break;
1570
1571         case R_SH_SWITCH8:
1572         case R_SH_SWITCH16:
1573         case R_SH_SWITCH32:
1574           /* These relocs types represent
1575                .word L2-L1
1576              The r_addend field holds the difference between the reloc
1577              address and L1.  That is the start of the reloc, and
1578              adding in the contents gives us the top.  We must adjust
1579              both the r_offset field and the section contents.
1580              N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1581              and the elf bfd r_offset is called r_vaddr.  */
1582
1583           stop = irel->r_offset;
1584           start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1585
1586           if (start > addr
1587               && start < toaddr
1588               && (stop <= addr || stop >= toaddr))
1589             irel->r_addend += count;
1590           else if (stop > addr
1591                    && stop < toaddr
1592                    && (start <= addr || start >= toaddr))
1593             irel->r_addend -= count;
1594
1595           if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1596             voff = bfd_get_signed_16 (abfd, contents + nraddr);
1597           else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1598             voff = bfd_get_8 (abfd, contents + nraddr);
1599           else
1600             voff = bfd_get_signed_32 (abfd, contents + nraddr);
1601           stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1602
1603           break;
1604
1605         case R_SH_USES:
1606           start = irel->r_offset;
1607           stop = (bfd_vma) ((bfd_signed_vma) start
1608                             + (long) irel->r_addend
1609                             + 4);
1610           break;
1611         }
1612
1613       if (start > addr
1614           && start < toaddr
1615           && (stop <= addr || stop >= toaddr))
1616         adjust = count;
1617       else if (stop > addr
1618                && stop < toaddr
1619                && (start <= addr || start >= toaddr))
1620         adjust = - count;
1621       else
1622         adjust = 0;
1623
1624       if (adjust != 0)
1625         {
1626           oinsn = insn;
1627           overflow = false;
1628           switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1629             {
1630             default:
1631               abort ();
1632               break;
1633
1634             case R_SH_DIR8WPN:
1635             case R_SH_DIR8WPZ:
1636               insn += adjust / 2;
1637               if ((oinsn & 0xff00) != (insn & 0xff00))
1638                 overflow = true;
1639               bfd_put_16 (abfd, insn, contents + nraddr);
1640               break;
1641
1642             case R_SH_IND12W:
1643               insn += adjust / 2;
1644               if ((oinsn & 0xf000) != (insn & 0xf000))
1645                 overflow = true;
1646               bfd_put_16 (abfd, insn, contents + nraddr);
1647               break;
1648
1649             case R_SH_DIR8WPL:
1650               BFD_ASSERT (adjust == count || count >= 4);
1651               if (count >= 4)
1652                 insn += adjust / 4;
1653               else
1654                 {
1655                   if ((irel->r_offset & 3) == 0)
1656                     ++insn;
1657                 }
1658               if ((oinsn & 0xff00) != (insn & 0xff00))
1659                 overflow = true;
1660               bfd_put_16 (abfd, insn, contents + nraddr);
1661               break;
1662
1663             case R_SH_SWITCH8:
1664               voff += adjust;
1665               if (voff < 0 || voff >= 0xff)
1666                 overflow = true;
1667               bfd_put_8 (abfd, voff, contents + nraddr);
1668               break;
1669
1670             case R_SH_SWITCH16:
1671               voff += adjust;
1672               if (voff < - 0x8000 || voff >= 0x8000)
1673                 overflow = true;
1674               bfd_put_signed_16 (abfd, voff, contents + nraddr);
1675               break;
1676
1677             case R_SH_SWITCH32:
1678               voff += adjust;
1679               bfd_put_signed_32 (abfd, voff, contents + nraddr);
1680               break;
1681
1682             case R_SH_USES:
1683               irel->r_addend += adjust;
1684               break;
1685             }
1686
1687           if (overflow)
1688             {
1689               ((*_bfd_error_handler)
1690                (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1691                 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1692               bfd_set_error (bfd_error_bad_value);
1693               return false;
1694             }
1695         }
1696
1697       irel->r_offset = nraddr;
1698     }
1699
1700   /* Look through all the other sections.  If there contain any IMM32
1701      relocs against internal symbols which we are not going to adjust
1702      below, we may need to adjust the addends.  */
1703   for (o = abfd->sections; o != NULL; o = o->next)
1704     {
1705       Elf_Internal_Rela *internal_relocs;
1706       Elf_Internal_Rela *irelscan, *irelscanend;
1707       bfd_byte *ocontents;
1708
1709       if (o == sec
1710           || (o->flags & SEC_RELOC) == 0
1711           || o->reloc_count == 0)
1712         continue;
1713
1714       /* We always cache the relocs.  Perhaps, if info->keep_memory is
1715          false, we should free them, if we are permitted to, when we
1716          leave sh_coff_relax_section.  */
1717       internal_relocs = (_bfd_elf32_link_read_relocs
1718                          (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1719                           true));
1720       if (internal_relocs == NULL)
1721         return false;
1722
1723       ocontents = NULL;
1724       irelscanend = internal_relocs + o->reloc_count;
1725       for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1726         {
1727           Elf_Internal_Sym sym;
1728
1729           /* Dwarf line numbers use R_SH_SWITCH32 relocs.  */
1730           if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1731             {
1732               bfd_vma start, stop;
1733               bfd_signed_vma voff;
1734
1735               if (ocontents == NULL)
1736                 {
1737                   if (elf_section_data (o)->this_hdr.contents != NULL)
1738                     ocontents = elf_section_data (o)->this_hdr.contents;
1739                   else
1740                     {
1741                       /* We always cache the section contents.
1742                          Perhaps, if info->keep_memory is false, we
1743                          should free them, if we are permitted to,
1744                          when we leave sh_coff_relax_section.  */
1745                       ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1746                       if (ocontents == NULL)
1747                         return false;
1748                       if (! bfd_get_section_contents (abfd, o, ocontents,
1749                                                       (file_ptr) 0,
1750                                                       o->_raw_size))
1751                         return false;
1752                       elf_section_data (o)->this_hdr.contents = ocontents;
1753                     }
1754                 }
1755
1756               stop = irelscan->r_offset;
1757               start
1758                 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1759
1760               /* STOP is in a different section, so it won't change.  */
1761               if (start > addr && start < toaddr)
1762                 irelscan->r_addend += count;
1763
1764               voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1765               stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1766
1767               if (start > addr
1768                   && start < toaddr
1769                   && (stop <= addr || stop >= toaddr))
1770                 bfd_put_signed_32 (abfd, voff + count,
1771                                    ocontents + irelscan->r_offset);
1772               else if (stop > addr
1773                        && stop < toaddr
1774                        && (start <= addr || start >= toaddr))
1775                 bfd_put_signed_32 (abfd, voff - count,
1776                                    ocontents + irelscan->r_offset);
1777             }
1778
1779           if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1780             continue;
1781
1782           if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1783             continue;
1784
1785           bfd_elf32_swap_symbol_in (abfd,
1786                                     extsyms + ELF32_R_SYM (irelscan->r_info),
1787                                     &sym);
1788
1789           if (sym.st_shndx == shndx
1790               && (sym.st_value <= addr
1791                   || sym.st_value >= toaddr))
1792             {
1793               bfd_vma val;
1794
1795               if (ocontents == NULL)
1796                 {
1797                   if (elf_section_data (o)->this_hdr.contents != NULL)
1798                     ocontents = elf_section_data (o)->this_hdr.contents;
1799                   else
1800                     {
1801                       /* We always cache the section contents.
1802                          Perhaps, if info->keep_memory is false, we
1803                          should free them, if we are permitted to,
1804                          when we leave sh_coff_relax_section.  */
1805                       ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1806                       if (ocontents == NULL)
1807                         return false;
1808                       if (! bfd_get_section_contents (abfd, o, ocontents,
1809                                                       (file_ptr) 0,
1810                                                       o->_raw_size))
1811                         return false;
1812                       elf_section_data (o)->this_hdr.contents = ocontents;
1813                     }
1814                 }
1815
1816               val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1817               val += sym.st_value;
1818               if (val > addr && val < toaddr)
1819                 bfd_put_32 (abfd, val - count,
1820                             ocontents + irelscan->r_offset);
1821             }
1822         }
1823     }
1824
1825   /* Adjust the local symbols defined in this section.  */
1826   esym = extsyms;
1827   esymend = esym + symtab_hdr->sh_info;
1828   for (; esym < esymend; esym++)
1829     {
1830       Elf_Internal_Sym isym;
1831
1832       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1833
1834       if (isym.st_shndx == shndx
1835           && isym.st_value > addr
1836           && isym.st_value < toaddr)
1837         {
1838           isym.st_value -= count;
1839           bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1840         }
1841     }
1842
1843   /* Now adjust the global symbols defined in this section.  */
1844   esym = extsyms + symtab_hdr->sh_info;
1845   esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1846   for (index = 0; esym < esymend; esym++, index++)
1847     {
1848       Elf_Internal_Sym isym;
1849
1850       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1851       sym_hash = elf_sym_hashes (abfd)[index];
1852       if (isym.st_shndx == shndx
1853           && ((sym_hash)->root.type == bfd_link_hash_defined
1854               || (sym_hash)->root.type == bfd_link_hash_defweak)
1855           && (sym_hash)->root.u.def.section == sec
1856           && (sym_hash)->root.u.def.value > addr
1857           && (sym_hash)->root.u.def.value < toaddr)
1858         {
1859           (sym_hash)->root.u.def.value -= count;
1860         }
1861     }
1862
1863   /* See if we can move the ALIGN reloc forward.  We have adjusted
1864      r_offset for it already.  */
1865   if (irelalign != NULL)
1866     {
1867       bfd_vma alignto, alignaddr;
1868
1869       alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1870       alignaddr = BFD_ALIGN (irelalign->r_offset,
1871                              1 << irelalign->r_addend);
1872       if (alignto != alignaddr)
1873         {
1874           /* Tail recursion.  */
1875           return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1876                                             alignto - alignaddr);
1877         }
1878     }
1879
1880   return true;
1881 }
1882
1883 /* Look for loads and stores which we can align to four byte
1884    boundaries.  This is like sh_align_loads in coff-sh.c.  */
1885
1886 static boolean
1887 sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
1888      bfd *abfd;
1889      asection *sec;
1890      Elf_Internal_Rela *internal_relocs;
1891      bfd_byte *contents;
1892      boolean *pswapped;
1893 {
1894   Elf_Internal_Rela *irel, *irelend;
1895   bfd_vma *labels = NULL;
1896   bfd_vma *label, *label_end;
1897
1898   *pswapped = false;
1899
1900   irelend = internal_relocs + sec->reloc_count;
1901
1902   /* Get all the addresses with labels on them.  */
1903   labels = (bfd_vma *) bfd_malloc (sec->reloc_count * sizeof (bfd_vma));
1904   if (labels == NULL)
1905     goto error_return;
1906   label_end = labels;
1907   for (irel = internal_relocs; irel < irelend; irel++)
1908     {
1909       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1910         {
1911           *label_end = irel->r_offset;
1912           ++label_end;
1913         }
1914     }
1915
1916   /* Note that the assembler currently always outputs relocs in
1917      address order.  If that ever changes, this code will need to sort
1918      the label values and the relocs.  */
1919
1920   label = labels;
1921
1922   for (irel = internal_relocs; irel < irelend; irel++)
1923     {
1924       bfd_vma start, stop;
1925
1926       if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1927         continue;
1928
1929       start = irel->r_offset;
1930
1931       for (irel++; irel < irelend; irel++)
1932         if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1933           break;
1934       if (irel < irelend)
1935         stop = irel->r_offset;
1936       else
1937         stop = sec->_cooked_size;
1938
1939       if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1940                                      (PTR) internal_relocs, &label,
1941                                      label_end, start, stop, pswapped))
1942         goto error_return;
1943     }
1944
1945   free (labels);
1946
1947   return true;
1948
1949  error_return:
1950   if (labels != NULL)
1951     free (labels);
1952   return false;
1953 }
1954
1955 /* Swap two SH instructions.  This is like sh_swap_insns in coff-sh.c.  */
1956
1957 static boolean
1958 sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
1959      bfd *abfd;
1960      asection *sec;
1961      PTR relocs;
1962      bfd_byte *contents;
1963      bfd_vma addr;
1964 {
1965   Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1966   unsigned short i1, i2;
1967   Elf_Internal_Rela *irel, *irelend;
1968
1969   /* Swap the instructions themselves.  */
1970   i1 = bfd_get_16 (abfd, contents + addr);
1971   i2 = bfd_get_16 (abfd, contents + addr + 2);
1972   bfd_put_16 (abfd, i2, contents + addr);
1973   bfd_put_16 (abfd, i1, contents + addr + 2);
1974
1975   /* Adjust all reloc addresses.  */
1976   irelend = internal_relocs + sec->reloc_count;
1977   for (irel = internal_relocs; irel < irelend; irel++)
1978     {
1979       enum elf_sh_reloc_type type;
1980       int add;
1981
1982       /* There are a few special types of relocs that we don't want to
1983          adjust.  These relocs do not apply to the instruction itself,
1984          but are only associated with the address.  */
1985       type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1986       if (type == R_SH_ALIGN
1987           || type == R_SH_CODE
1988           || type == R_SH_DATA
1989           || type == R_SH_LABEL)
1990         continue;
1991
1992       /* If an R_SH_USES reloc points to one of the addresses being
1993          swapped, we must adjust it.  It would be incorrect to do this
1994          for a jump, though, since we want to execute both
1995          instructions after the jump.  (We have avoided swapping
1996          around a label, so the jump will not wind up executing an
1997          instruction it shouldn't).  */
1998       if (type == R_SH_USES)
1999         {
2000           bfd_vma off;
2001
2002           off = irel->r_offset + 4 + irel->r_addend;
2003           if (off == addr)
2004             irel->r_offset += 2;
2005           else if (off == addr + 2)
2006             irel->r_offset -= 2;
2007         }
2008
2009       if (irel->r_offset == addr)
2010         {
2011           irel->r_offset += 2;
2012           add = -2;
2013         }
2014       else if (irel->r_offset == addr + 2)
2015         {
2016           irel->r_offset -= 2;
2017           add = 2;
2018         }
2019       else
2020         add = 0;
2021
2022       if (add != 0)
2023         {
2024           bfd_byte *loc;
2025           unsigned short insn, oinsn;
2026           boolean overflow;
2027
2028           loc = contents + irel->r_offset;
2029           overflow = false;
2030           switch (type)
2031             {
2032             default:
2033               break;
2034
2035             case R_SH_DIR8WPN:
2036             case R_SH_DIR8WPZ:
2037               insn = bfd_get_16 (abfd, loc);
2038               oinsn = insn;
2039               insn += add / 2;
2040               if ((oinsn & 0xff00) != (insn & 0xff00))
2041                 overflow = true;
2042               bfd_put_16 (abfd, insn, loc);
2043               break;
2044
2045             case R_SH_IND12W:
2046               insn = bfd_get_16 (abfd, loc);
2047               oinsn = insn;
2048               insn += add / 2;
2049               if ((oinsn & 0xf000) != (insn & 0xf000))
2050                 overflow = true;
2051               bfd_put_16 (abfd, insn, loc);
2052               break;
2053
2054             case R_SH_DIR8WPL:
2055               /* This reloc ignores the least significant 3 bits of
2056                  the program counter before adding in the offset.
2057                  This means that if ADDR is at an even address, the
2058                  swap will not affect the offset.  If ADDR is an at an
2059                  odd address, then the instruction will be crossing a
2060                  four byte boundary, and must be adjusted.  */
2061               if ((addr & 3) != 0)
2062                 {
2063                   insn = bfd_get_16 (abfd, loc);
2064                   oinsn = insn;
2065                   insn += add / 2;
2066                   if ((oinsn & 0xff00) != (insn & 0xff00))
2067                     overflow = true;
2068                   bfd_put_16 (abfd, insn, loc);
2069                 }
2070
2071               break;
2072             }
2073
2074           if (overflow)
2075             {
2076               ((*_bfd_error_handler)
2077                (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
2078                 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
2079               bfd_set_error (bfd_error_bad_value);
2080               return false;
2081             }
2082         }
2083     }
2084
2085   return true;
2086 }
2087 \f
2088 /* The size in bytes of an entry in the procedure linkage table.  */
2089
2090 #define PLT_ENTRY_SIZE 28
2091
2092 /* First entry in an absolute procedure linkage table look like this.  */
2093
2094 #if 1
2095 /* Note - this code has been "optimised" not to use r2.  r2 is used by
2096    GCC to return the address of large strutcures, so it should not be
2097    corrupted here.  This does mean however, that this PLT does not conform
2098    to the SH PIC ABI.  That spec says that r0 contains the type of the PLT
2099    and r2 contains the GOT id.  This version stores the GOT id in r0 and
2100    ignores the type.  Loaders can easily detect this difference however,
2101    since the type will always be 0 or 8, and the GOT ids will always be
2102    greater than or equal to 12.  */
2103 static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
2104 {
2105   0xd0, 0x05,   /* mov.l 2f,r0 */
2106   0x60, 0x02,   /* mov.l @r0,r0 */
2107   0x2f, 0x06,   /* mov.l r0,@-r15 */
2108   0xd0, 0x03,   /* mov.l 1f,r0 */
2109   0x60, 0x02,   /* mov.l @r0,r0 */
2110   0x40, 0x2b,   /* jmp @r0 */
2111   0x60, 0xf6,   /*  mov.l @r15+,r0 */
2112   0x00, 0x09,   /* nop */
2113   0x00, 0x09,   /* nop */
2114   0x00, 0x09,   /* nop */
2115   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
2116   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
2117 };
2118
2119 static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
2120 {
2121   0x05, 0xd0,   /* mov.l 2f,r0 */
2122   0x02, 0x60,   /* mov.l @r0,r0 */
2123   0x06, 0x2f,   /* mov.l r0,@-r15 */
2124   0x03, 0xd0,   /* mov.l 1f,r0 */
2125   0x02, 0x60,   /* mov.l @r0,r0 */
2126   0x2b, 0x40,   /* jmp @r0 */
2127   0xf6, 0x60,   /*  mov.l @r15+,r0 */
2128   0x09, 0x00,   /* nop */
2129   0x09, 0x00,   /* nop */
2130   0x09, 0x00,   /* nop */
2131   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
2132   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
2133 };
2134
2135 /* Sebsequent entries in an absolute procedure linkage table look like
2136    this.  */
2137
2138 static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
2139 {
2140   0xd0, 0x04,   /* mov.l 1f,r0 */
2141   0x60, 0x02,   /* mov.l @r0,r0 */
2142   0xd1, 0x02,   /* mov.l 0f,r1 */
2143   0x40, 0x2b,   /* jmp @r0 */
2144   0x60, 0x13,   /*  mov r1,r0 */
2145   0xd1, 0x03,   /* mov.l 2f,r1 */
2146   0x40, 0x2b,   /* jmp @r0 */
2147   0x00, 0x09,   /* nop */
2148   0, 0, 0, 0,   /* 0: replaced with address of .PLT0.  */
2149   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
2150   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
2151 };
2152
2153 static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
2154 {
2155   0x04, 0xd0,   /* mov.l 1f,r0 */
2156   0x02, 0x60,   /* mov.l @r0,r0 */
2157   0x02, 0xd1,   /* mov.l 0f,r1 */
2158   0x2b, 0x40,   /* jmp @r0 */
2159   0x13, 0x60,   /*  mov r1,r0 */
2160   0x03, 0xd1,   /* mov.l 2f,r1 */
2161   0x2b, 0x40,   /* jmp @r0 */
2162   0x09, 0x00,   /*  nop */
2163   0, 0, 0, 0,   /* 0: replaced with address of .PLT0.  */
2164   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
2165   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
2166 };
2167
2168 /* Entries in a PIC procedure linkage table look like this.  */
2169
2170 static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2171 {
2172   0xd0, 0x04,   /* mov.l 1f,r0 */
2173   0x00, 0xce,   /* mov.l @(r0,r12),r0 */
2174   0x40, 0x2b,   /* jmp @r0 */
2175   0x00, 0x09,   /*  nop */
2176   0x50, 0xc2,   /* mov.l @(8,r12),r0 */
2177   0xd1, 0x03,   /* mov.l 2f,r1 */
2178   0x40, 0x2b,   /* jmp @r0 */
2179   0x50, 0xc1,   /*  mov.l @(4,r12),r0 */
2180   0x00, 0x09,   /* nop */
2181   0x00, 0x09,   /* nop */
2182   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
2183   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
2184 };
2185
2186 static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
2187 {
2188   0x04, 0xd0,   /* mov.l 1f,r0 */
2189   0xce, 0x00,   /* mov.l @(r0,r12),r0 */
2190   0x2b, 0x40,   /* jmp @r0 */
2191   0x09, 0x00,   /*  nop */
2192   0xc2, 0x50,   /* mov.l @(8,r12),r0 */
2193   0x03, 0xd1,   /* mov.l 2f,r1 */
2194   0x2b, 0x40,   /* jmp @r0 */
2195   0xc1, 0x50,   /*  mov.l @(4,r12),r0 */
2196   0x09, 0x00,   /*  nop */
2197   0x09, 0x00,   /* nop */
2198   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
2199   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
2200 };
2201
2202 #else /* These are the old style PLT entries.  */
2203 static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
2204 {
2205   0xd0, 0x04,   /* mov.l 1f,r0 */
2206   0xd2, 0x05,   /* mov.l 2f,r2 */
2207   0x60, 0x02,   /* mov.l @r0,r0 */
2208   0x62, 0x22,   /* mov.l @r2,r2 */
2209   0x40, 0x2b,   /* jmp @r0 */
2210   0xe0, 0x00,   /*  mov #0,r0 */
2211   0x00, 0x09,   /* nop */
2212   0x00, 0x09,   /* nop */
2213   0x00, 0x09,   /* nop */
2214   0x00, 0x09,   /* nop */
2215   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
2216   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
2217 };
2218
2219 static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
2220 {
2221   0x04, 0xd0,   /* mov.l 1f,r0 */
2222   0x05, 0xd2,   /* mov.l 2f,r2 */
2223   0x02, 0x60,   /* mov.l @r0,r0 */
2224   0x22, 0x62,   /* mov.l @r2,r2 */
2225   0x2b, 0x40,   /* jmp @r0 */
2226   0x00, 0xe0,   /*  mov #0,r0 */
2227   0x09, 0x00,   /* nop */
2228   0x09, 0x00,   /* nop */
2229   0x09, 0x00,   /* nop */
2230   0x09, 0x00,   /* nop */
2231   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
2232   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
2233 };
2234
2235 /* Sebsequent entries in an absolute procedure linkage table look like
2236    this.  */
2237
2238 static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
2239 {
2240   0xd0, 0x04,   /* mov.l 1f,r0 */
2241   0x60, 0x02,   /* mov.l @r0,r0 */
2242   0xd2, 0x02,   /* mov.l 0f,r2 */
2243   0x40, 0x2b,   /* jmp @r0 */
2244   0x60, 0x23,   /*  mov r2,r0 */
2245   0xd1, 0x03,   /* mov.l 2f,r1 */
2246   0x40, 0x2b,   /* jmp @r0 */
2247   0x00, 0x09,   /* nop */
2248   0, 0, 0, 0,   /* 0: replaced with address of .PLT0.  */
2249   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
2250   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
2251 };
2252
2253 static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
2254 {
2255   0x04, 0xd0,   /* mov.l 1f,r0 */
2256   0x02, 0x60,   /* mov.l @r0,r0 */
2257   0x02, 0xd2,   /* mov.l 0f,r2 */
2258   0x2b, 0x40,   /* jmp @r0 */
2259   0x23, 0x60,   /*  mov r2,r0 */
2260   0x03, 0xd1,   /* mov.l 2f,r1 */
2261   0x2b, 0x40,   /* jmp @r0 */
2262   0x09, 0x00,   /*  nop */
2263   0, 0, 0, 0,   /* 0: replaced with address of .PLT.  */
2264   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
2265   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
2266 };
2267
2268 /* Entries in a PIC procedure linkage table look like this.  */
2269
2270 static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2271 {
2272   0xd0, 0x04,   /* mov.l 1f,r0 */
2273   0x00, 0xce,   /* mov.l @(r0,r12),r0 */
2274   0x40, 0x2b,   /* jmp @r0 */
2275   0x00, 0x09,   /*  nop */
2276   0x50, 0xc2,   /* 0: mov.l @(8,r12),r0 */
2277   0x52, 0xc1,   /* 1: mov.l @(4,r12),r2 */
2278   0xd1, 0x02,   /* mov.l 2f,r1 */
2279   0x40, 0x2b,   /* jmp @r0 */
2280   0xe0, 0x00,   /*  mov #0,r0 ! shows the type of PLT.  */
2281   0x00, 0x09,   /* nop */
2282   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
2283   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
2284 };
2285
2286 static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
2287 {
2288   0x04, 0xd0,   /* mov.l 1f,r0 */
2289   0xce, 0x00,   /* mov.l @(r0,r12),r0 */
2290   0x2b, 0x40,   /* jmp @r0 */
2291   0x09, 0x00,   /*  nop */
2292   0xc2, 0x50,   /* 0: mov.l @(8,r12),r0 */
2293   0xc1, 0x52,   /* 1: mov.l @(4,r12),r2 */
2294   0x02, 0xd1,   /* mov.l 2f,r1 */
2295   0x2b, 0x40,   /* jmp @r0 */
2296   0x00, 0xe0,   /*  mov #0,r0 ! shows the type of PLT.  */
2297   0x09, 0x00,   /* nop */
2298   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
2299   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
2300 };
2301 #endif /* old style PLT entries.  */
2302
2303 static const bfd_byte *elf_sh_plt0_entry;
2304 static const bfd_byte *elf_sh_plt_entry;
2305 static const bfd_byte *elf_sh_pic_plt_entry;
2306
2307 /* Return size of a PLT entry.  */
2308 #define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
2309
2310 /* Return offset of the PLT0 address in an absolute PLT entry.  */
2311 #define elf_sh_plt_plt0_offset(info) 16
2312
2313 /* Return offset of the linker in PLT0 entry.  */
2314 #define elf_sh_plt0_linker_offset(info) 20
2315
2316 /* Return offset of the GOT id in PLT0 entry.  */
2317 #define elf_sh_plt0_gotid_offset(info) 24
2318
2319 /* Return offset of the tempoline in PLT entry */
2320 #define elf_sh_plt_temp_offset(info) 8
2321
2322 /* Return offset of the symbol in PLT entry.  */
2323 #define elf_sh_plt_symbol_offset(info) 20
2324
2325 /* Return offset of the relocation in PLT entry.  */
2326 #define elf_sh_plt_reloc_offset(info) 24
2327
2328 /* The sh linker needs to keep track of the number of relocs that it
2329    decides to copy in check_relocs for each symbol.  This is so that
2330    it can discard PC relative relocs if it doesn't need them when
2331    linking with -Bsymbolic.  We store the information in a field
2332    extending the regular ELF linker hash table.  */
2333
2334 /* This structure keeps track of the number of PC relative relocs we
2335    have copied for a given symbol.  */
2336
2337 struct elf_sh_pcrel_relocs_copied
2338 {
2339   /* Next section.  */
2340   struct elf_sh_pcrel_relocs_copied *next;
2341   /* A section in dynobj.  */
2342   asection *section;
2343   /* Number of relocs copied in this section.  */
2344   bfd_size_type count;
2345 };
2346
2347 /* sh ELF linker hash entry.  */
2348
2349 struct elf_sh_link_hash_entry
2350 {
2351   struct elf_link_hash_entry root;
2352
2353   /* Number of PC relative relocs copied for this symbol.  */
2354   struct elf_sh_pcrel_relocs_copied *pcrel_relocs_copied;
2355 };
2356
2357 /* sh ELF linker hash table.  */
2358
2359 struct elf_sh_link_hash_table
2360 {
2361   struct elf_link_hash_table root;
2362 };
2363
2364 /* Declare this now that the above structures are defined.  */
2365
2366 static boolean sh_elf_discard_copies
2367   PARAMS ((struct elf_sh_link_hash_entry *, PTR));
2368
2369 /* Traverse an sh ELF linker hash table.  */
2370
2371 #define sh_elf_link_hash_traverse(table, func, info)                    \
2372   (elf_link_hash_traverse                                               \
2373    (&(table)->root,                                                     \
2374     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
2375     (info)))
2376
2377 /* Get the sh ELF linker hash table from a link_info structure.  */
2378
2379 #define sh_elf_hash_table(p) \
2380   ((struct elf_sh_link_hash_table *) ((p)->hash))
2381
2382 /* Create an entry in an sh ELF linker hash table.  */
2383
2384 static struct bfd_hash_entry *
2385 sh_elf_link_hash_newfunc (entry, table, string)
2386      struct bfd_hash_entry *entry;
2387      struct bfd_hash_table *table;
2388      const char *string;
2389 {
2390   struct elf_sh_link_hash_entry *ret =
2391     (struct elf_sh_link_hash_entry *) entry;
2392
2393   /* Allocate the structure if it has not already been allocated by a
2394      subclass.  */
2395   if (ret == (struct elf_sh_link_hash_entry *) NULL)
2396     ret = ((struct elf_sh_link_hash_entry *)
2397            bfd_hash_allocate (table,
2398                               sizeof (struct elf_sh_link_hash_entry)));
2399   if (ret == (struct elf_sh_link_hash_entry *) NULL)
2400     return (struct bfd_hash_entry *) ret;
2401
2402   /* Call the allocation method of the superclass.  */
2403   ret = ((struct elf_sh_link_hash_entry *)
2404          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2405                                      table, string));
2406   if (ret != (struct elf_sh_link_hash_entry *) NULL)
2407     {
2408       ret->pcrel_relocs_copied = NULL;
2409     }
2410
2411   return (struct bfd_hash_entry *) ret;
2412 }
2413
2414 /* Create an sh ELF linker hash table.  */
2415
2416 static struct bfd_link_hash_table *
2417 sh_elf_link_hash_table_create (abfd)
2418      bfd *abfd;
2419 {
2420   struct elf_sh_link_hash_table *ret;
2421
2422   ret = ((struct elf_sh_link_hash_table *)
2423          bfd_alloc (abfd, sizeof (struct elf_sh_link_hash_table)));
2424   if (ret == (struct elf_sh_link_hash_table *) NULL)
2425     return NULL;
2426
2427   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2428                                        sh_elf_link_hash_newfunc))
2429     {
2430       bfd_release (abfd, ret);
2431       return NULL;
2432     }
2433
2434   return &ret->root.root;
2435 }
2436
2437 /* Create dynamic sections when linking against a dynamic object.  */
2438
2439 static boolean
2440 sh_elf_create_dynamic_sections (abfd, info)
2441      bfd *abfd;
2442      struct bfd_link_info *info;
2443 {
2444   flagword flags, pltflags;
2445   register asection *s;
2446   struct elf_backend_data *bed = get_elf_backend_data (abfd);
2447   int ptralign = 0;
2448
2449   switch (bed->s->arch_size)
2450     {
2451     case 32:
2452       ptralign = 2;
2453       break;
2454
2455     case 64:
2456       ptralign = 3;
2457       break;
2458
2459     default:
2460       bfd_set_error (bfd_error_bad_value);
2461       return false;
2462     }
2463
2464   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2465      .rel[a].bss sections.  */
2466
2467   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2468            | SEC_LINKER_CREATED);
2469
2470   pltflags = flags;
2471   pltflags |= SEC_CODE;
2472   if (bed->plt_not_loaded)
2473     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2474   if (bed->plt_readonly)
2475     pltflags |= SEC_READONLY;
2476
2477   s = bfd_make_section (abfd, ".plt");
2478   if (s == NULL
2479       || ! bfd_set_section_flags (abfd, s, pltflags)
2480       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2481     return false;
2482
2483   if (bed->want_plt_sym)
2484     {
2485       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2486          .plt section.  */
2487       struct elf_link_hash_entry *h = NULL;
2488       if (! (_bfd_generic_link_add_one_symbol
2489              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2490               (bfd_vma) 0, (const char *) NULL, false,
2491               get_elf_backend_data (abfd)->collect,
2492               (struct bfd_link_hash_entry **) &h)))
2493         return false;
2494       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2495       h->type = STT_OBJECT;
2496
2497       if (info->shared
2498           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2499         return false;
2500     }
2501
2502   s = bfd_make_section (abfd,
2503                         bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
2504   if (s == NULL
2505       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2506       || ! bfd_set_section_alignment (abfd, s, ptralign))
2507     return false;
2508
2509   if (! _bfd_elf_create_got_section (abfd, info))
2510     return false;
2511
2512   {
2513     const char *secname;
2514     char *relname;
2515     flagword secflags;
2516     asection *sec;
2517
2518     for (sec = abfd->sections; sec; sec = sec->next)
2519       {
2520         secflags = bfd_get_section_flags (abfd, sec);
2521         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
2522             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
2523           continue;
2524         secname = bfd_get_section_name (abfd, sec);
2525         relname = (char *) bfd_malloc (strlen (secname) + 6);
2526         strcpy (relname, ".rela");
2527         strcat (relname, secname);
2528         s = bfd_make_section (abfd, relname);
2529         if (s == NULL
2530             || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2531             || ! bfd_set_section_alignment (abfd, s, ptralign))
2532           return false;
2533       }
2534   }
2535
2536   if (bed->want_dynbss)
2537     {
2538       /* The .dynbss section is a place to put symbols which are defined
2539          by dynamic objects, are referenced by regular objects, and are
2540          not functions.  We must allocate space for them in the process
2541          image and use a R_*_COPY reloc to tell the dynamic linker to
2542          initialize them at run time.  The linker script puts the .dynbss
2543          section into the .bss section of the final image.  */
2544       s = bfd_make_section (abfd, ".dynbss");
2545       if (s == NULL
2546           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
2547         return false;
2548
2549       /* The .rel[a].bss section holds copy relocs.  This section is not
2550          normally needed.  We need to create it here, though, so that the
2551          linker will map it to an output section.  We can't just create it
2552          only if we need it, because we will not know whether we need it
2553          until we have seen all the input files, and the first time the
2554          main linker code calls BFD after examining all the input files
2555          (size_dynamic_sections) the input sections have already been
2556          mapped to the output sections.  If the section turns out not to
2557          be needed, we can discard it later.  We will never need this
2558          section when generating a shared object, since they do not use
2559          copy relocs.  */
2560       if (! info->shared)
2561         {
2562           s = bfd_make_section (abfd,
2563                                 (bed->default_use_rela_p
2564                                  ? ".rela.bss" : ".rel.bss"));
2565           if (s == NULL
2566               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2567               || ! bfd_set_section_alignment (abfd, s, ptralign))
2568             return false;
2569         }
2570     }
2571
2572   return true;
2573 }
2574 \f
2575 /* Adjust a symbol defined by a dynamic object and referenced by a
2576    regular object.  The current definition is in some section of the
2577    dynamic object, but we're not including those sections.  We have to
2578    change the definition to something the rest of the link can
2579    understand.  */
2580
2581 static boolean
2582 sh_elf_adjust_dynamic_symbol (info, h)
2583      struct bfd_link_info *info;
2584      struct elf_link_hash_entry *h;
2585 {
2586   bfd *dynobj;
2587   asection *s;
2588   unsigned int power_of_two;
2589
2590   dynobj = elf_hash_table (info)->dynobj;
2591
2592   /* Make sure we know what is going on here.  */
2593   BFD_ASSERT (dynobj != NULL
2594               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2595                   || h->weakdef != NULL
2596                   || ((h->elf_link_hash_flags
2597                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2598                       && (h->elf_link_hash_flags
2599                           & ELF_LINK_HASH_REF_REGULAR) != 0
2600                       && (h->elf_link_hash_flags
2601                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2602
2603   /* If this is a function, put it in the procedure linkage table.  We
2604      will fill in the contents of the procedure linkage table later,
2605      when we know the address of the .got section.  */
2606   if (h->type == STT_FUNC
2607       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2608     {
2609       if (! info->shared
2610           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2611           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2612         {
2613           /* This case can occur if we saw a PLT reloc in an input
2614              file, but the symbol was never referred to by a dynamic
2615              object.  In such a case, we don't actually need to build
2616              a procedure linkage table, and we can just do a REL32
2617              reloc instead.  */
2618           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2619           return true;
2620         }
2621
2622       /* Make sure this symbol is output as a dynamic symbol.  */
2623       if (h->dynindx == -1)
2624         {
2625           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2626             return false;
2627         }
2628
2629       s = bfd_get_section_by_name (dynobj, ".plt");
2630       BFD_ASSERT (s != NULL);
2631
2632       /* If this is the first .plt entry, make room for the special
2633          first entry.  */
2634       if (s->_raw_size == 0)
2635         s->_raw_size += PLT_ENTRY_SIZE;
2636
2637       /* If this symbol is not defined in a regular file, and we are
2638          not generating a shared library, then set the symbol to this
2639          location in the .plt.  This is required to make function
2640          pointers compare as equal between the normal executable and
2641          the shared library.  */
2642       if (! info->shared
2643           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2644         {
2645           h->root.u.def.section = s;
2646           h->root.u.def.value = s->_raw_size;
2647         }
2648
2649       h->plt.offset = s->_raw_size;
2650
2651       /* Make room for this entry.  */
2652       s->_raw_size += elf_sh_sizeof_plt (info);
2653
2654       /* We also need to make an entry in the .got.plt section, which
2655          will be placed in the .got section by the linker script.  */
2656
2657       s = bfd_get_section_by_name (dynobj, ".got.plt");
2658       BFD_ASSERT (s != NULL);
2659       s->_raw_size += 4;
2660
2661       /* We also need to make an entry in the .rela.plt section.  */
2662
2663       s = bfd_get_section_by_name (dynobj, ".rela.plt");
2664       BFD_ASSERT (s != NULL);
2665       s->_raw_size += sizeof (Elf32_External_Rela);
2666
2667       return true;
2668     }
2669
2670   /* If this is a weak symbol, and there is a real definition, the
2671      processor independent code will have arranged for us to see the
2672      real definition first, and we can just use the same value.  */
2673   if (h->weakdef != NULL)
2674     {
2675       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2676                   || h->weakdef->root.type == bfd_link_hash_defweak);
2677       h->root.u.def.section = h->weakdef->root.u.def.section;
2678       h->root.u.def.value = h->weakdef->root.u.def.value;
2679       return true;
2680     }
2681
2682   /* This is a reference to a symbol defined by a dynamic object which
2683      is not a function.  */
2684
2685   /* If we are creating a shared library, we must presume that the
2686      only references to the symbol are via the global offset table.
2687      For such cases we need not do anything here; the relocations will
2688      be handled correctly by relocate_section.  */
2689   if (info->shared)
2690     return true;
2691
2692   /* If there are no references to this symbol that do not use the
2693      GOT, we don't need to generate a copy reloc.  */
2694   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2695     return true;
2696
2697   /* We must allocate the symbol in our .dynbss section, which will
2698      become part of the .bss section of the executable.  There will be
2699      an entry for this symbol in the .dynsym section.  The dynamic
2700      object will contain position independent code, so all references
2701      from the dynamic object to this symbol will go through the global
2702      offset table.  The dynamic linker will use the .dynsym entry to
2703      determine the address it must put in the global offset table, so
2704      both the dynamic object and the regular object will refer to the
2705      same memory location for the variable.  */
2706
2707   s = bfd_get_section_by_name (dynobj, ".dynbss");
2708   BFD_ASSERT (s != NULL);
2709
2710   /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2711      copy the initial value out of the dynamic object and into the
2712      runtime process image.  We need to remember the offset into the
2713      .rela.bss section we are going to use.  */
2714   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2715     {
2716       asection *srel;
2717
2718       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
2719       BFD_ASSERT (srel != NULL);
2720       srel->_raw_size += sizeof (Elf32_External_Rela);
2721       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2722     }
2723
2724   /* We need to figure out the alignment required for this symbol.  I
2725      have no idea how ELF linkers handle this.  */
2726   power_of_two = bfd_log2 (h->size);
2727   if (power_of_two > 3)
2728     power_of_two = 3;
2729
2730   /* Apply the required alignment.  */
2731   s->_raw_size = BFD_ALIGN (s->_raw_size,
2732                             (bfd_size_type) (1 << power_of_two));
2733   if (power_of_two > bfd_get_section_alignment (dynobj, s))
2734     {
2735       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2736         return false;
2737     }
2738
2739   /* Define the symbol as being at this point in the section.  */
2740   h->root.u.def.section = s;
2741   h->root.u.def.value = s->_raw_size;
2742
2743   /* Increment the section size to make room for the symbol.  */
2744   s->_raw_size += h->size;
2745
2746   return true;
2747 }
2748
2749 /* Set the sizes of the dynamic sections.  */
2750
2751 static boolean
2752 sh_elf_size_dynamic_sections (output_bfd, info)
2753      bfd *output_bfd;
2754      struct bfd_link_info *info;
2755 {
2756   bfd *dynobj;
2757   asection *s;
2758   boolean plt;
2759   boolean relocs;
2760   boolean reltext;
2761
2762   dynobj = elf_hash_table (info)->dynobj;
2763   BFD_ASSERT (dynobj != NULL);
2764
2765   if (elf_hash_table (info)->dynamic_sections_created)
2766     {
2767       /* Set the contents of the .interp section to the interpreter.  */
2768       if (! info->shared)
2769         {
2770           s = bfd_get_section_by_name (dynobj, ".interp");
2771           BFD_ASSERT (s != NULL);
2772           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2773           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2774         }
2775     }
2776   else
2777     {
2778       /* We may have created entries in the .rela.got section.
2779          However, if we are not creating the dynamic sections, we will
2780          not actually use these entries.  Reset the size of .rela.got,
2781          which will cause it to get stripped from the output file
2782          below.  */
2783       s = bfd_get_section_by_name (dynobj, ".rela.got");
2784       if (s != NULL)
2785         s->_raw_size = 0;
2786     }
2787
2788   /* If this is a -Bsymbolic shared link, then we need to discard all
2789      PC relative relocs against symbols defined in a regular object.
2790      We allocated space for them in the check_relocs routine, but we
2791      will not fill them in in the relocate_section routine.  */
2792   if (info->shared && info->symbolic)
2793     sh_elf_link_hash_traverse (sh_elf_hash_table (info),
2794                                  sh_elf_discard_copies,
2795                                  (PTR) NULL);
2796
2797   /* The check_relocs and adjust_dynamic_symbol entry points have
2798      determined the sizes of the various dynamic sections.  Allocate
2799      memory for them.  */
2800   plt = false;
2801   relocs = false;
2802   reltext = false;
2803   for (s = dynobj->sections; s != NULL; s = s->next)
2804     {
2805       const char *name;
2806       boolean strip;
2807
2808       if ((s->flags & SEC_LINKER_CREATED) == 0)
2809         continue;
2810
2811       /* It's OK to base decisions on the section name, because none
2812          of the dynobj section names depend upon the input files.  */
2813       name = bfd_get_section_name (dynobj, s);
2814
2815       strip = false;
2816
2817       if (strcmp (name, ".plt") == 0)
2818         {
2819           if (s->_raw_size == 0)
2820             {
2821               /* Strip this section if we don't need it; see the
2822                  comment below.  */
2823               strip = true;
2824             }
2825           else
2826             {
2827               /* Remember whether there is a PLT.  */
2828               plt = true;
2829             }
2830         }
2831       else if (strncmp (name, ".rela", 5) == 0)
2832         {
2833           if (s->_raw_size == 0)
2834             {
2835               /* If we don't need this section, strip it from the
2836                  output file.  This is mostly to handle .rela.bss and
2837                  .rela.plt.  We must create both sections in
2838                  create_dynamic_sections, because they must be created
2839                  before the linker maps input sections to output
2840                  sections.  The linker does that before
2841                  adjust_dynamic_symbol is called, and it is that
2842                  function which decides whether anything needs to go
2843                  into these sections.  */
2844               strip = true;
2845             }
2846           else
2847             {
2848               asection *target;
2849
2850               /* Remember whether there are any reloc sections other
2851                  than .rela.plt.  */
2852               if (strcmp (name, ".rela.plt") != 0)
2853                 {
2854                   const char *outname;
2855
2856                   relocs = true;
2857
2858                   /* If this relocation section applies to a read only
2859                      section, then we probably need a DT_TEXTREL
2860                      entry.  The entries in the .rela.plt section
2861                      really apply to the .got section, which we
2862                      created ourselves and so know is not readonly.  */
2863                   outname = bfd_get_section_name (output_bfd,
2864                                                   s->output_section);
2865                   target = bfd_get_section_by_name (output_bfd, outname + 5);
2866                   if (target != NULL
2867                       && (target->flags & SEC_READONLY) != 0
2868                       && (target->flags & SEC_ALLOC) != 0)
2869                     reltext = true;
2870                 }
2871
2872               /* We use the reloc_count field as a counter if we need
2873                  to copy relocs into the output file.  */
2874               s->reloc_count = 0;
2875             }
2876         }
2877       else if (strncmp (name, ".got", 4) != 0)
2878         {
2879           /* It's not one of our sections, so don't allocate space.  */
2880           continue;
2881         }
2882
2883       if (strip)
2884         {
2885           _bfd_strip_section_from_output (info, s);
2886           continue;
2887         }
2888
2889       /* Allocate memory for the section contents.  */
2890       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
2891       if (s->contents == NULL && s->_raw_size != 0)
2892         return false;
2893     }
2894
2895   if (elf_hash_table (info)->dynamic_sections_created)
2896     {
2897       /* Add some entries to the .dynamic section.  We fill in the
2898          values later, in sh_elf_finish_dynamic_sections, but we
2899          must add the entries now so that we get the correct size for
2900          the .dynamic section.  The DT_DEBUG entry is filled in by the
2901          dynamic linker and used by the debugger.  */
2902       if (! info->shared)
2903         {
2904           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2905             return false;
2906         }
2907
2908       if (plt)
2909         {
2910           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2911               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2912               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2913               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2914             return false;
2915         }
2916
2917       if (relocs)
2918         {
2919           if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
2920               || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
2921               || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
2922                                                 sizeof (Elf32_External_Rela)))
2923             return false;
2924         }
2925
2926       if (reltext)
2927         {
2928           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2929             return false;
2930         }
2931     }
2932
2933   return true;
2934 }
2935
2936 /* This function is called via sh_elf_link_hash_traverse if we are
2937    creating a shared object with -Bsymbolic.  It discards the space
2938    allocated to copy PC relative relocs against symbols which are
2939    defined in regular objects.  We allocated space for them in the
2940    check_relocs routine, but we won't fill them in in the
2941    relocate_section routine.  */
2942
2943 static boolean
2944 sh_elf_discard_copies (h, ignore)
2945      struct elf_sh_link_hash_entry *h;
2946      PTR ignore ATTRIBUTE_UNUSED;
2947 {
2948   struct elf_sh_pcrel_relocs_copied *s;
2949
2950   /* We only discard relocs for symbols defined in a regular object.  */
2951   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2952     return true;
2953
2954   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2955     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
2956
2957   return true;
2958 }
2959 \f
2960 /* Relocate an SH ELF section.  */
2961
2962 static boolean
2963 sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
2964                          contents, relocs, local_syms, local_sections)
2965      bfd *output_bfd ATTRIBUTE_UNUSED;
2966      struct bfd_link_info *info;
2967      bfd *input_bfd;
2968      asection *input_section;
2969      bfd_byte *contents;
2970      Elf_Internal_Rela *relocs;
2971      Elf_Internal_Sym *local_syms;
2972      asection **local_sections;
2973 {
2974   Elf_Internal_Shdr *symtab_hdr;
2975   struct elf_link_hash_entry **sym_hashes;
2976   Elf_Internal_Rela *rel, *relend;
2977   bfd *dynobj;
2978   bfd_vma *local_got_offsets;
2979   asection *sgot;
2980   asection *splt;
2981   asection *sreloc;
2982
2983   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2984   sym_hashes = elf_sym_hashes (input_bfd);
2985   dynobj = elf_hash_table (info)->dynobj;
2986   local_got_offsets = elf_local_got_offsets (input_bfd);
2987
2988   sgot = NULL;
2989   splt = NULL;
2990   sreloc = NULL;
2991
2992   rel = relocs;
2993   relend = relocs + input_section->reloc_count;
2994   for (; rel < relend; rel++)
2995     {
2996       int r_type;
2997       reloc_howto_type *howto;
2998       unsigned long r_symndx;
2999       Elf_Internal_Sym *sym;
3000       asection *sec;
3001       struct elf_link_hash_entry *h;
3002       bfd_vma relocation;
3003       bfd_vma addend = (bfd_vma) 0;
3004       bfd_reloc_status_type r;
3005
3006       r_symndx = ELF32_R_SYM (rel->r_info);
3007
3008       r_type = ELF32_R_TYPE (rel->r_info);
3009
3010       /* Many of the relocs are only used for relaxing, and are
3011          handled entirely by the relaxation code.  */
3012       if (r_type > (int) R_SH_LAST_INVALID_RELOC
3013           && r_type < (int) R_SH_LOOP_START)
3014         continue;
3015       if (r_type == (int) R_SH_NONE)
3016         continue;
3017
3018       if (r_type < 0
3019           || r_type >= R_SH_max
3020           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
3021               && r_type <= (int) R_SH_LAST_INVALID_RELOC)
3022           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
3023               && r_type <= (int) R_SH_LAST_INVALID_RELOC_2))
3024         {
3025           bfd_set_error (bfd_error_bad_value);
3026           return false;
3027         }
3028
3029       howto = sh_elf_howto_table + r_type;
3030
3031       /* This is a final link.  */
3032       h = NULL;
3033       sym = NULL;
3034       sec = NULL;
3035       if (r_symndx < symtab_hdr->sh_info)
3036         {
3037           sym = local_syms + r_symndx;
3038           sec = local_sections[r_symndx];
3039           relocation = (sec->output_section->vma
3040                         + sec->output_offset
3041                         + sym->st_value);
3042
3043           if (info->relocateable)
3044             {
3045               /* This is a relocateable link.  We don't have to change
3046                  anything, unless the reloc is against a section symbol,
3047                  in which case we have to adjust according to where the
3048                  section symbol winds up in the output section.  */
3049               sym = local_syms + r_symndx;
3050               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3051                 goto final_link_relocate;
3052
3053               continue;
3054             }
3055         }
3056       else
3057         {
3058           /* Section symbol are never (?) placed in the hash table, so
3059              we can just ignore hash relocations when creating a
3060              relocateable object file.  */
3061           if (info->relocateable)
3062             continue;
3063
3064           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3065           while (h->root.type == bfd_link_hash_indirect
3066                  || h->root.type == bfd_link_hash_warning)
3067             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3068           if (h->root.type == bfd_link_hash_defined
3069               || h->root.type == bfd_link_hash_defweak)
3070             {
3071               sec = h->root.u.def.section;
3072               /* In these cases, we don't need the relocation value.
3073                  We check specially because in some obscure cases
3074                  sec->output_section will be NULL.  */
3075               if (r_type == R_SH_GOTPC
3076                   || (r_type == R_SH_PLT32
3077                       && h->plt.offset != (bfd_vma) -1)
3078                   || (r_type == R_SH_GOT32
3079                       && elf_hash_table (info)->dynamic_sections_created
3080                       && (! info->shared
3081                           || (! info->symbolic && h->dynindx != -1)
3082                           || (h->elf_link_hash_flags
3083                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
3084                   /* The cases above are those in which relocation is
3085                      overwritten in the switch block below.  The cases
3086                      below are those in which we must defer relocation
3087                      to run-time, because we can't resolve absolute
3088                      addresses when creating a shared library.  */
3089                   || (info->shared
3090                       && ((! info->symbolic && h->dynindx != -1)
3091                           || (h->elf_link_hash_flags
3092                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
3093                       && ((r_type == R_SH_DIR32
3094                            && !(ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3095                                 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN))
3096                           || r_type == R_SH_REL32)
3097                       && ((input_section->flags & SEC_ALLOC) != 0
3098                           /* DWARF will emit R_SH_DIR32 relocations in its
3099                              sections against symbols defined externally
3100                              in shared libraries.  We can't do anything
3101                              with them here.  */
3102                           || (input_section->flags & SEC_DEBUGGING) != 0)))
3103                 relocation = 0;
3104               else if (sec->output_section == NULL)
3105                 {
3106                   (*_bfd_error_handler)
3107                     (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
3108                      bfd_get_filename (input_bfd), h->root.root.string,
3109                      bfd_get_section_name (input_bfd, input_section));
3110                   relocation = 0;
3111                 }
3112               else
3113                 relocation = (h->root.u.def.value
3114                               + sec->output_section->vma
3115                               + sec->output_offset);
3116             }
3117           else if (h->root.type == bfd_link_hash_undefweak)
3118             relocation = 0;
3119           else if (info->shared && !info->symbolic && !info->no_undefined)
3120             relocation = 0;
3121           else
3122             {
3123               if (! ((*info->callbacks->undefined_symbol)
3124                      (info, h->root.root.string, input_bfd,
3125                       input_section, rel->r_offset, true)))
3126                 return false;
3127               relocation = 0;
3128             }
3129         }
3130
3131       switch ((int) r_type)
3132         {
3133         final_link_relocate:
3134           /* COFF relocs don't use the addend. The addend is used for
3135              R_SH_DIR32 to be compatible with other compilers.  */
3136           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3137                                         contents, rel->r_offset,
3138                                         relocation, addend);
3139           break;
3140
3141         case R_SH_IND12W:
3142           relocation -= 4;
3143           goto final_link_relocate;
3144
3145         case R_SH_DIR8WPN:
3146         case R_SH_DIR8WPZ:
3147         case R_SH_DIR8WPL:
3148           /* If the reloc is against the start of this section, then
3149              the assembler has already taken care of it and the reloc
3150              is here only to assist in relaxing.  If the reloc is not
3151              against the start of this section, then it's against an
3152              external symbol and we must deal with it ourselves.  */
3153           if (input_section->output_section->vma + input_section->output_offset
3154               != relocation)
3155             {
3156               int disp = (relocation
3157                           - input_section->output_section->vma
3158                           - input_section->output_offset
3159                           - rel->r_offset);
3160               int mask = 0;
3161               switch (r_type)
3162                 {
3163                 case R_SH_DIR8WPN:
3164                 case R_SH_DIR8WPZ: mask = 1; break;
3165                 case R_SH_DIR8WPL: mask = 3; break;
3166                 default: mask = 0; break;
3167                 }
3168               if (disp & mask)
3169                 {
3170                   ((*_bfd_error_handler)
3171                    (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
3172                     bfd_get_filename (input_section->owner),
3173                     (unsigned long) rel->r_offset));
3174                   bfd_set_error (bfd_error_bad_value);
3175                   return false;
3176                 }
3177               relocation -= 4;
3178               goto final_link_relocate;
3179             }
3180           r = bfd_reloc_ok;
3181           break;
3182
3183         default:
3184           bfd_set_error (bfd_error_bad_value);
3185           return false;
3186
3187         case R_SH_DIR32:
3188         case R_SH_REL32:
3189           if (info->shared
3190               && (input_section->flags & SEC_ALLOC) != 0
3191               && (r_type != R_SH_REL32
3192                   || (h != NULL
3193                       && h->dynindx != -1
3194                       && (! info->symbolic
3195                           || (h->elf_link_hash_flags
3196                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3197             {
3198               Elf_Internal_Rela outrel;
3199               boolean skip, relocate;
3200
3201               /* When generating a shared object, these relocations
3202                  are copied into the output file to be resolved at run
3203                  time.  */
3204
3205               if (sreloc == NULL)
3206                 {
3207                   const char *name;
3208
3209                   name = (bfd_elf_string_from_elf_section
3210                           (input_bfd,
3211                            elf_elfheader (input_bfd)->e_shstrndx,
3212                            elf_section_data (input_section)->rel_hdr.sh_name));
3213                   if (name == NULL)
3214                     return false;
3215
3216                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3217                               && strcmp (bfd_get_section_name (input_bfd,
3218                                                                input_section),
3219                                          name + 5) == 0);
3220
3221                   sreloc = bfd_get_section_by_name (dynobj, name);
3222                   BFD_ASSERT (sreloc != NULL);
3223                 }
3224
3225               skip = false;
3226
3227               if (elf_section_data (input_section)->stab_info == NULL)
3228                 outrel.r_offset = rel->r_offset;
3229               else
3230                 {
3231                   bfd_vma off;
3232
3233                   off = (_bfd_stab_section_offset
3234                          (output_bfd, &elf_hash_table (info)->stab_info,
3235                           input_section,
3236                           &elf_section_data (input_section)->stab_info,
3237                           rel->r_offset));
3238                   if (off == (bfd_vma) -1)
3239                     skip = true;
3240                   outrel.r_offset = off;
3241                 }
3242
3243               outrel.r_offset += (input_section->output_section->vma
3244                                   + input_section->output_offset);
3245
3246               if (skip)
3247                 {
3248                   memset (&outrel, 0, sizeof outrel);
3249                   relocate = false;
3250                 }
3251               else if (r_type == R_SH_REL32)
3252                 {
3253                   BFD_ASSERT (h != NULL && h->dynindx != -1);
3254                   relocate = false;
3255                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
3256                   outrel.r_addend = rel->r_addend;
3257                 }
3258               else
3259                 {
3260                   /* h->dynindx may be -1 if this symbol was marked to
3261                      become local.  */
3262                   if (h == NULL
3263                       || ((info->symbolic || h->dynindx == -1)
3264                           && (h->elf_link_hash_flags
3265                               & ELF_LINK_HASH_DEF_REGULAR) != 0))
3266                     {
3267                       relocate = true;
3268                       outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
3269                       outrel.r_addend = relocation + rel->r_addend;
3270                     }
3271                   else
3272                     {
3273                       BFD_ASSERT (h->dynindx != -1);
3274                       relocate = false;
3275                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
3276                       outrel.r_addend = relocation + rel->r_addend;
3277                     }
3278                 }
3279
3280               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3281                                          (((Elf32_External_Rela *)
3282                                            sreloc->contents)
3283                                           + sreloc->reloc_count));
3284               ++sreloc->reloc_count;
3285
3286               /* If this reloc is against an external symbol, we do
3287                  not want to fiddle with the addend.  Otherwise, we
3288                  need to include the symbol value so that it becomes
3289                  an addend for the dynamic reloc.  */
3290               if (! relocate)
3291                 continue;
3292             }
3293           else if (r_type == R_SH_DIR32)
3294             addend = rel->r_addend;
3295           goto final_link_relocate;
3296
3297         case R_SH_GOT32:
3298           /* Relocation is to the entry for this symbol in the global
3299              offset table.  */
3300           if (sgot == NULL)
3301             {
3302               sgot = bfd_get_section_by_name (dynobj, ".got");
3303               BFD_ASSERT (sgot != NULL);
3304             }
3305
3306           if (h != NULL)
3307             {
3308               bfd_vma off;
3309
3310               off = h->got.offset;
3311               BFD_ASSERT (off != (bfd_vma) -1);
3312
3313               if (! elf_hash_table (info)->dynamic_sections_created
3314                   || (info->shared
3315                       && (info->symbolic || h->dynindx == -1
3316                           || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3317                           || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3318                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3319                 {
3320                   /* This is actually a static link, or it is a
3321                      -Bsymbolic link and the symbol is defined
3322                      locally, or the symbol was forced to be local
3323                      because of a version file.  We must initialize
3324                      this entry in the global offset table.  Since the
3325                      offset must always be a multiple of 4, we use the
3326                      least significant bit to record whether we have
3327                      initialized it already.
3328
3329                      When doing a dynamic link, we create a .rela.got
3330                      relocation entry to initialize the value.  This
3331                      is done in the finish_dynamic_symbol routine.  */
3332                   if ((off & 1) != 0)
3333                     off &= ~1;
3334                   else
3335                     {
3336                       bfd_put_32 (output_bfd, relocation,
3337                                   sgot->contents + off);
3338                       h->got.offset |= 1;
3339                     }
3340                 }
3341
3342               relocation = sgot->output_offset + off;
3343             }
3344           else
3345             {
3346               bfd_vma off;
3347
3348               BFD_ASSERT (local_got_offsets != NULL
3349                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
3350
3351               off = local_got_offsets[r_symndx];
3352
3353               /* The offset must always be a multiple of 4.  We use
3354                  the least significant bit to record whether we have
3355                  already generated the necessary reloc.  */
3356               if ((off & 1) != 0)
3357                 off &= ~1;
3358               else
3359                 {
3360                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
3361
3362                   if (info->shared)
3363                     {
3364                       asection *srelgot;
3365                       Elf_Internal_Rela outrel;
3366
3367                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3368                       BFD_ASSERT (srelgot != NULL);
3369
3370                       outrel.r_offset = (sgot->output_section->vma
3371                                          + sgot->output_offset
3372                                          + off);
3373                       outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
3374                       outrel.r_addend = relocation;
3375                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3376                                                 (((Elf32_External_Rela *)
3377                                                   srelgot->contents)
3378                                                  + srelgot->reloc_count));
3379                       ++srelgot->reloc_count;
3380                     }
3381
3382                   local_got_offsets[r_symndx] |= 1;
3383                 }
3384
3385               relocation = sgot->output_offset + off;
3386             }
3387
3388           goto final_link_relocate;
3389
3390         case R_SH_GOTOFF:
3391           /* Relocation is relative to the start of the global offset
3392              table.  */
3393
3394           if (sgot == NULL)
3395             {
3396               sgot = bfd_get_section_by_name (dynobj, ".got");
3397               BFD_ASSERT (sgot != NULL);
3398             }
3399
3400           /* Note that sgot->output_offset is not involved in this
3401              calculation.  We always want the start of .got.  If we
3402              defined _GLOBAL_OFFSET_TABLE in a different way, as is
3403              permitted by the ABI, we might have to change this
3404              calculation.  */
3405           relocation -= sgot->output_section->vma;
3406
3407           goto final_link_relocate;
3408
3409         case R_SH_GOTPC:
3410           /* Use global offset table as symbol value.  */
3411
3412           if (sgot == NULL)
3413             {
3414               sgot = bfd_get_section_by_name (dynobj, ".got");
3415               BFD_ASSERT (sgot != NULL);
3416             }
3417
3418           relocation = sgot->output_section->vma;
3419
3420           goto final_link_relocate;
3421
3422         case R_SH_PLT32:
3423           /* Relocation is to the entry for this symbol in the
3424              procedure linkage table.  */
3425
3426           /* Resolve a PLT reloc against a local symbol directly,
3427              without using the procedure linkage table.  */
3428           if (h == NULL)
3429             goto final_link_relocate;
3430
3431           if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3432               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3433             goto final_link_relocate;
3434
3435           if (h->plt.offset == (bfd_vma) -1)
3436             {
3437               /* We didn't make a PLT entry for this symbol.  This
3438                  happens when statically linking PIC code, or when
3439                  using -Bsymbolic.  */
3440               goto final_link_relocate;
3441             }
3442
3443           if (splt == NULL)
3444             {
3445               splt = bfd_get_section_by_name (dynobj, ".plt");
3446               BFD_ASSERT (splt != NULL);
3447             }
3448
3449           relocation = (splt->output_section->vma
3450                         + splt->output_offset
3451                         + h->plt.offset);
3452
3453           goto final_link_relocate;
3454
3455         case R_SH_LOOP_START:
3456           {
3457             static bfd_vma start, end;
3458
3459             start = (relocation + rel->r_addend
3460                      - (sec->output_section->vma + sec->output_offset));
3461             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
3462                                    rel->r_offset, sec, start, end);
3463             break;
3464
3465         case R_SH_LOOP_END:
3466             end = (relocation + rel->r_addend
3467                    - (sec->output_section->vma + sec->output_offset));
3468             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
3469                                    rel->r_offset, sec, start, end);
3470             break;
3471           }
3472         }
3473
3474       if (r != bfd_reloc_ok)
3475         {
3476           switch (r)
3477             {
3478             default:
3479             case bfd_reloc_outofrange:
3480               abort ();
3481             case bfd_reloc_overflow:
3482               {
3483                 const char *name;
3484
3485                 if (h != NULL)
3486                   name = h->root.root.string;
3487                 else
3488                   {
3489                     name = (bfd_elf_string_from_elf_section
3490                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
3491                     if (name == NULL)
3492                       return false;
3493                     if (*name == '\0')
3494                       name = bfd_section_name (input_bfd, sec);
3495                   }
3496                 if (! ((*info->callbacks->reloc_overflow)
3497                        (info, name, howto->name, (bfd_vma) 0,
3498                         input_bfd, input_section, rel->r_offset)))
3499                   return false;
3500               }
3501               break;
3502             }
3503         }
3504     }
3505
3506   return true;
3507 }
3508
3509 /* This is a version of bfd_generic_get_relocated_section_contents
3510    which uses sh_elf_relocate_section.  */
3511
3512 static bfd_byte *
3513 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
3514                                        data, relocateable, symbols)
3515      bfd *output_bfd;
3516      struct bfd_link_info *link_info;
3517      struct bfd_link_order *link_order;
3518      bfd_byte *data;
3519      boolean relocateable;
3520      asymbol **symbols;
3521 {
3522   Elf_Internal_Shdr *symtab_hdr;
3523   asection *input_section = link_order->u.indirect.section;
3524   bfd *input_bfd = input_section->owner;
3525   asection **sections = NULL;
3526   Elf_Internal_Rela *internal_relocs = NULL;
3527   Elf32_External_Sym *external_syms = NULL;
3528   Elf_Internal_Sym *internal_syms = NULL;
3529
3530   /* We only need to handle the case of relaxing, or of having a
3531      particular set of section contents, specially.  */
3532   if (relocateable
3533       || elf_section_data (input_section)->this_hdr.contents == NULL)
3534     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3535                                                        link_order, data,
3536                                                        relocateable,
3537                                                        symbols);
3538
3539   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3540
3541   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3542           input_section->_raw_size);
3543
3544   if ((input_section->flags & SEC_RELOC) != 0
3545       && input_section->reloc_count > 0)
3546     {
3547       Elf_Internal_Sym *isymp;
3548       asection **secpp;
3549       Elf32_External_Sym *esym, *esymend;
3550
3551       if (symtab_hdr->contents != NULL)
3552         external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
3553       else
3554         {
3555           external_syms = ((Elf32_External_Sym *)
3556                            bfd_malloc (symtab_hdr->sh_info
3557                                        * sizeof (Elf32_External_Sym)));
3558           if (external_syms == NULL && symtab_hdr->sh_info > 0)
3559             goto error_return;
3560           if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
3561               || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
3562                             symtab_hdr->sh_info, input_bfd)
3563                   != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
3564             goto error_return;
3565         }
3566
3567       internal_relocs = (_bfd_elf32_link_read_relocs
3568                          (input_bfd, input_section, (PTR) NULL,
3569                           (Elf_Internal_Rela *) NULL, false));
3570       if (internal_relocs == NULL)
3571         goto error_return;
3572
3573       internal_syms = ((Elf_Internal_Sym *)
3574                        bfd_malloc (symtab_hdr->sh_info
3575                                    * sizeof (Elf_Internal_Sym)));
3576       if (internal_syms == NULL && symtab_hdr->sh_info > 0)
3577         goto error_return;
3578
3579       sections = (asection **) bfd_malloc (symtab_hdr->sh_info
3580                                            * sizeof (asection *));
3581       if (sections == NULL && symtab_hdr->sh_info > 0)
3582         goto error_return;
3583
3584       isymp = internal_syms;
3585       secpp = sections;
3586       esym = external_syms;
3587       esymend = esym + symtab_hdr->sh_info;
3588       for (; esym < esymend; ++esym, ++isymp, ++secpp)
3589         {
3590           asection *isec;
3591
3592           bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
3593
3594           if (isymp->st_shndx == SHN_UNDEF)
3595             isec = bfd_und_section_ptr;
3596           else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
3597             isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
3598           else if (isymp->st_shndx == SHN_ABS)
3599             isec = bfd_abs_section_ptr;
3600           else if (isymp->st_shndx == SHN_COMMON)
3601             isec = bfd_com_section_ptr;
3602           else
3603             {
3604               /* Who knows?  */
3605               isec = NULL;
3606             }
3607
3608           *secpp = isec;
3609         }
3610
3611       if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
3612                                      input_section, data, internal_relocs,
3613                                      internal_syms, sections))
3614         goto error_return;
3615
3616       if (sections != NULL)
3617         free (sections);
3618       sections = NULL;
3619       if (internal_syms != NULL)
3620         free (internal_syms);
3621       internal_syms = NULL;
3622       if (external_syms != NULL && symtab_hdr->contents == NULL)
3623         free (external_syms);
3624       external_syms = NULL;
3625       if (internal_relocs != elf_section_data (input_section)->relocs)
3626         free (internal_relocs);
3627       internal_relocs = NULL;
3628     }
3629
3630   return data;
3631
3632  error_return:
3633   if (internal_relocs != NULL
3634       && internal_relocs != elf_section_data (input_section)->relocs)
3635     free (internal_relocs);
3636   if (external_syms != NULL && symtab_hdr->contents == NULL)
3637     free (external_syms);
3638   if (internal_syms != NULL)
3639     free (internal_syms);
3640   if (sections != NULL)
3641     free (sections);
3642   return NULL;
3643 }
3644 static asection *
3645 sh_elf_gc_mark_hook (abfd, info, rel, h, sym)
3646      bfd *abfd;
3647      struct bfd_link_info *info ATTRIBUTE_UNUSED;
3648      Elf_Internal_Rela *rel;
3649      struct elf_link_hash_entry *h;
3650      Elf_Internal_Sym *sym;
3651 {
3652   if (h != NULL)
3653     {
3654       switch (ELF32_R_TYPE (rel->r_info))
3655         {
3656         case R_SH_GNU_VTINHERIT:
3657         case R_SH_GNU_VTENTRY:
3658           break;
3659
3660         default:
3661           switch (h->root.type)
3662             {
3663             case bfd_link_hash_defined:
3664             case bfd_link_hash_defweak:
3665               return h->root.u.def.section;
3666
3667             case bfd_link_hash_common:
3668               return h->root.u.c.p->section;
3669
3670             default:
3671               break;
3672             }
3673         }
3674     }
3675   else
3676     {
3677       if (!(elf_bad_symtab (abfd)
3678             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
3679           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
3680                 && sym->st_shndx != SHN_COMMON))
3681         return bfd_section_from_elf_index (abfd, sym->st_shndx);
3682     }
3683   return NULL;
3684 }
3685
3686 /* Update the got entry reference counts for the section being removed.  */
3687
3688 static boolean
3689 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
3690      bfd *abfd ATTRIBUTE_UNUSED;
3691      struct bfd_link_info *info ATTRIBUTE_UNUSED;
3692      asection *sec ATTRIBUTE_UNUSED;
3693      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
3694 {
3695   /* We use got and plt entries for sh, but it would seem that the
3696      existing SH code does no sort of reference counting or whatnot on
3697      its GOT and PLT entries, so it is not possible to garbage collect
3698      them at this time.  */
3699   return true;
3700 }
3701
3702 /* Look through the relocs for a section during the first phase.
3703    Since we don't do .gots or .plts, we just need to consider the
3704    virtual table relocs for gc.  */
3705
3706 static boolean
3707 sh_elf_check_relocs (abfd, info, sec, relocs)
3708      bfd *abfd;
3709      struct bfd_link_info *info;
3710      asection *sec;
3711      const Elf_Internal_Rela *relocs;
3712 {
3713   Elf_Internal_Shdr *symtab_hdr;
3714   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
3715   const Elf_Internal_Rela *rel;
3716   const Elf_Internal_Rela *rel_end;
3717   bfd *dynobj;
3718   bfd_vma *local_got_offsets;
3719   asection *sgot;
3720   asection *srelgot;
3721   asection *sreloc;
3722
3723   sgot = NULL;
3724   srelgot = NULL;
3725   sreloc = NULL;
3726
3727   if (info->relocateable)
3728     return true;
3729
3730   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3731   sym_hashes = elf_sym_hashes (abfd);
3732   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
3733   if (!elf_bad_symtab (abfd))
3734     sym_hashes_end -= symtab_hdr->sh_info;
3735
3736   dynobj = elf_hash_table (info)->dynobj;
3737   local_got_offsets = elf_local_got_offsets (abfd);
3738
3739   rel_end = relocs + sec->reloc_count;
3740   for (rel = relocs; rel < rel_end; rel++)
3741     {
3742       struct elf_link_hash_entry *h;
3743       unsigned long r_symndx;
3744
3745       r_symndx = ELF32_R_SYM (rel->r_info);
3746       if (r_symndx < symtab_hdr->sh_info)
3747         h = NULL;
3748       else
3749         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3750
3751       /* Some relocs require a global offset table.  */
3752       if (dynobj == NULL)
3753         {
3754           switch (ELF32_R_TYPE (rel->r_info))
3755             {
3756             case R_SH_GOT32:
3757             case R_SH_GOTOFF:
3758             case R_SH_GOTPC:
3759               elf_hash_table (info)->dynobj = dynobj = abfd;
3760               if (! _bfd_elf_create_got_section (dynobj, info))
3761                 return false;
3762               break;
3763
3764             default:
3765               break;
3766             }
3767         }
3768
3769       switch (ELF32_R_TYPE (rel->r_info))
3770         {
3771         /* This relocation describes the C++ object vtable hierarchy.
3772            Reconstruct it for later use during GC.  */
3773         case R_SH_GNU_VTINHERIT:
3774           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3775             return false;
3776           break;
3777
3778         /* This relocation describes which C++ vtable entries are actually
3779            used.  Record for later use during GC.  */
3780         case R_SH_GNU_VTENTRY:
3781           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3782             return false;
3783           break;
3784
3785         case R_SH_GOT32:
3786           /* This symbol requires a global offset table entry.  */
3787
3788           if (sgot == NULL)
3789             {
3790               sgot = bfd_get_section_by_name (dynobj, ".got");
3791               BFD_ASSERT (sgot != NULL);
3792             }
3793
3794           if (srelgot == NULL
3795               && (h != NULL || info->shared))
3796             {
3797               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3798               if (srelgot == NULL)
3799                 {
3800                   srelgot = bfd_make_section (dynobj, ".rela.got");
3801                   if (srelgot == NULL
3802                       || ! bfd_set_section_flags (dynobj, srelgot,
3803                                                   (SEC_ALLOC
3804                                                    | SEC_LOAD
3805                                                    | SEC_HAS_CONTENTS
3806                                                    | SEC_IN_MEMORY
3807                                                    | SEC_LINKER_CREATED
3808                                                    | SEC_READONLY))
3809                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
3810                     return false;
3811                 }
3812             }
3813
3814           if (h != NULL)
3815             {
3816               if (h->got.offset != (bfd_vma) -1)
3817                 {
3818                   /* We have already allocated space in the .got.  */
3819                   break;
3820                 }
3821               h->got.offset = sgot->_raw_size;
3822
3823               /* Make sure this symbol is output as a dynamic symbol.  */
3824               if (h->dynindx == -1)
3825                 {
3826                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
3827                     return false;
3828                 }
3829
3830               srelgot->_raw_size += sizeof (Elf32_External_Rela);
3831             }
3832           else
3833             {
3834               /* This is a global offset table entry for a local
3835                  symbol.  */
3836               if (local_got_offsets == NULL)
3837                 {
3838                   size_t size;
3839                   register unsigned int i;
3840
3841                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
3842                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
3843                   if (local_got_offsets == NULL)
3844                     return false;
3845                   elf_local_got_offsets (abfd) = local_got_offsets;
3846                   for (i = 0; i < symtab_hdr->sh_info; i++)
3847                     local_got_offsets[i] = (bfd_vma) -1;
3848                 }
3849               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
3850                 {
3851                   /* We have already allocated space in the .got.  */
3852                   break;
3853                 }
3854               local_got_offsets[r_symndx] = sgot->_raw_size;
3855
3856               if (info->shared)
3857                 {
3858                   /* If we are generating a shared object, we need to
3859                      output a R_SH_RELATIVE reloc so that the dynamic
3860                      linker can adjust this GOT entry.  */
3861                   srelgot->_raw_size += sizeof (Elf32_External_Rela);
3862                 }
3863             }
3864
3865           sgot->_raw_size += 4;
3866
3867           break;
3868
3869         case R_SH_PLT32:
3870           /* This symbol requires a procedure linkage table entry.  We
3871              actually build the entry in adjust_dynamic_symbol,
3872              because this might be a case of linking PIC code which is
3873              never referenced by a dynamic object, in which case we
3874              don't need to generate a procedure linkage table entry
3875              after all.  */
3876
3877           /* If this is a local symbol, we resolve it directly without
3878              creating a procedure linkage table entry.  */
3879           if (h == NULL)
3880             continue;
3881
3882           if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3883               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3884             break;
3885
3886           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3887
3888           break;
3889
3890         case R_SH_DIR32:
3891         case R_SH_REL32:
3892           if (h != NULL)
3893             h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
3894
3895           /* If we are creating a shared library, and this is a reloc
3896              against a global symbol, or a non PC relative reloc
3897              against a local symbol, then we need to copy the reloc
3898              into the shared library.  However, if we are linking with
3899              -Bsymbolic, we do not need to copy a reloc against a
3900              global symbol which is defined in an object we are
3901              including in the link (i.e., DEF_REGULAR is set).  At
3902              this point we have not seen all the input files, so it is
3903              possible that DEF_REGULAR is not set now but will be set
3904              later (it is never cleared).  We account for that
3905              possibility below by storing information in the
3906              pcrel_relocs_copied field of the hash table entry.  */
3907           if (info->shared
3908               && (sec->flags & SEC_ALLOC) != 0
3909               && (ELF32_R_TYPE (rel->r_info) != R_SH_REL32
3910                   || (h != NULL
3911                       && (! info->symbolic
3912                           || (h->elf_link_hash_flags
3913                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3914             {
3915               /* When creating a shared object, we must copy these
3916                  reloc types into the output file.  We create a reloc
3917                  section in dynobj and make room for this reloc.  */
3918               if (sreloc == NULL)
3919                 {
3920                   const char *name;
3921
3922                   name = (bfd_elf_string_from_elf_section
3923                           (abfd,
3924                            elf_elfheader (abfd)->e_shstrndx,
3925                            elf_section_data (sec)->rel_hdr.sh_name));
3926                   if (name == NULL)
3927                     return false;
3928
3929                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3930                               && strcmp (bfd_get_section_name (abfd, sec),
3931                                          name + 5) == 0);
3932
3933                   sreloc = bfd_get_section_by_name (dynobj, name);
3934                   if (sreloc == NULL)
3935                     {
3936                       flagword flags;
3937
3938                       sreloc = bfd_make_section (dynobj, name);
3939                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
3940                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3941                       if ((sec->flags & SEC_ALLOC) != 0)
3942                         flags |= SEC_ALLOC | SEC_LOAD;
3943                       if (sreloc == NULL
3944                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
3945                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
3946                         return false;
3947                     }
3948                 }
3949
3950               sreloc->_raw_size += sizeof (Elf32_External_Rela);
3951
3952               /* If we are linking with -Bsymbolic, and this is a
3953                  global symbol, we count the number of PC relative
3954                  relocations we have entered for this symbol, so that
3955                  we can discard them again if the symbol is later
3956                  defined by a regular object.  Note that this function
3957                  is only called if we are using an elf_sh linker
3958                  hash table, which means that h is really a pointer to
3959                  an elf_sh_link_hash_entry.  */
3960               if (h != NULL && info->symbolic
3961                   && ELF32_R_TYPE (rel->r_info) == R_SH_REL32)
3962                 {
3963                   struct elf_sh_link_hash_entry *eh;
3964                   struct elf_sh_pcrel_relocs_copied *p;
3965
3966                   eh = (struct elf_sh_link_hash_entry *) h;
3967
3968                   for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
3969                     if (p->section == sreloc)
3970                       break;
3971
3972                   if (p == NULL)
3973                     {
3974                       p = ((struct elf_sh_pcrel_relocs_copied *)
3975                            bfd_alloc (dynobj, sizeof *p));
3976                       if (p == NULL)
3977                         return false;
3978                       p->next = eh->pcrel_relocs_copied;
3979                       eh->pcrel_relocs_copied = p;
3980                       p->section = sreloc;
3981                       p->count = 0;
3982                     }
3983
3984                   ++p->count;
3985                 }
3986             }
3987
3988           break;
3989         }
3990     }
3991
3992   return true;
3993 }
3994
3995 static boolean
3996 sh_elf_set_mach_from_flags (abfd)
3997      bfd *abfd;
3998 {
3999   flagword flags = elf_elfheader (abfd)->e_flags;
4000
4001   switch (flags & EF_SH_MACH_MASK)
4002     {
4003     case EF_SH1:
4004       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
4005       break;
4006     case EF_SH2:
4007       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
4008       break;
4009     case EF_SH_DSP:
4010       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
4011       break;
4012     case EF_SH3:
4013       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
4014       break;
4015     case EF_SH3_DSP:
4016       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
4017       break;
4018     case EF_SH3E:
4019       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
4020       break;
4021     case EF_SH_UNKNOWN:
4022     case EF_SH4:
4023       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
4024       break;
4025     default:
4026       return false;
4027     }
4028   return true;
4029 }
4030
4031 /* Function to keep SH specific file flags.  */
4032
4033 static boolean
4034 sh_elf_set_private_flags (abfd, flags)
4035      bfd *abfd;
4036      flagword flags;
4037 {
4038   BFD_ASSERT (! elf_flags_init (abfd)
4039               || elf_elfheader (abfd)->e_flags == flags);
4040
4041   elf_elfheader (abfd)->e_flags = flags;
4042   elf_flags_init (abfd) = true;
4043   return sh_elf_set_mach_from_flags (abfd);
4044 }
4045
4046 /* Copy backend specific data from one object module to another */
4047
4048 static boolean
4049 sh_elf_copy_private_data (ibfd, obfd)
4050      bfd * ibfd;
4051      bfd * obfd;
4052 {
4053   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4054       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4055     return true;
4056
4057   return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
4058 }
4059
4060 /* This routine checks for linking big and little endian objects
4061    together, and for linking sh-dsp with sh3e / sh4 objects.  */
4062
4063 static boolean
4064 sh_elf_merge_private_data (ibfd, obfd)
4065      bfd *ibfd;
4066      bfd *obfd;
4067 {
4068   flagword old_flags, new_flags;
4069
4070   if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
4071     return false;
4072
4073   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4074       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4075     return true;
4076
4077   if (! elf_flags_init (obfd))
4078     {
4079       /* This happens when ld starts out with a 'blank' output file.  */
4080       elf_flags_init (obfd) = true;
4081       elf_elfheader (obfd)->e_flags = EF_SH1;
4082     }
4083   old_flags = elf_elfheader (obfd)->e_flags;
4084   new_flags = elf_elfheader (ibfd)->e_flags;
4085   if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
4086       || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
4087     {
4088       (*_bfd_error_handler)
4089         ("%s: uses %s instructions while previous modules use %s instructions",
4090          bfd_get_filename (ibfd),
4091          EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
4092          EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
4093       bfd_set_error (bfd_error_bad_value);
4094       return false;
4095     }
4096   elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
4097
4098   return sh_elf_set_mach_from_flags (obfd);
4099 }
4100
4101 /* Finish up dynamic symbol handling.  We set the contents of various
4102    dynamic sections here.  */
4103
4104 static boolean
4105 sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
4106      bfd *output_bfd;
4107      struct bfd_link_info *info;
4108      struct elf_link_hash_entry *h;
4109      Elf_Internal_Sym *sym;
4110 {
4111   bfd *dynobj;
4112
4113   dynobj = elf_hash_table (info)->dynobj;
4114
4115   if (h->plt.offset != (bfd_vma) -1)
4116     {
4117       asection *splt;
4118       asection *sgot;
4119       asection *srel;
4120
4121       bfd_vma plt_index;
4122       bfd_vma got_offset;
4123       Elf_Internal_Rela rel;
4124
4125       /* This symbol has an entry in the procedure linkage table.  Set
4126          it up.  */
4127
4128       BFD_ASSERT (h->dynindx != -1);
4129
4130       splt = bfd_get_section_by_name (dynobj, ".plt");
4131       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4132       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4133       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4134
4135       /* Get the index in the procedure linkage table which
4136          corresponds to this symbol.  This is the index of this symbol
4137          in all the symbols for which we are making plt entries.  The
4138          first entry in the procedure linkage table is reserved.  */
4139       plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
4140
4141       /* Get the offset into the .got table of the entry that
4142          corresponds to this function.  Each .got entry is 4 bytes.
4143          The first three are reserved.  */
4144       got_offset = (plt_index + 3) * 4;
4145
4146       /* Fill in the entry in the procedure linkage table.  */
4147       if (! info->shared)
4148         {
4149           if (elf_sh_plt_entry == NULL)
4150             {
4151               elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
4152                                   elf_sh_plt_entry_be : elf_sh_plt_entry_le);
4153             }
4154           memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
4155                   elf_sh_sizeof_plt (info));
4156           bfd_put_32 (output_bfd,
4157                       (sgot->output_section->vma
4158                        + sgot->output_offset
4159                        + got_offset),
4160                       (splt->contents + h->plt.offset
4161                        + elf_sh_plt_symbol_offset (info)));
4162
4163           bfd_put_32 (output_bfd,
4164                       (splt->output_section->vma + splt->output_offset),
4165                       (splt->contents + h->plt.offset
4166                        + elf_sh_plt_plt0_offset (info)));
4167         }
4168       else
4169         {
4170           if (elf_sh_pic_plt_entry == NULL)
4171             {
4172               elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
4173                                       elf_sh_pic_plt_entry_be :
4174                                       elf_sh_pic_plt_entry_le);
4175             }
4176           memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
4177                   elf_sh_sizeof_plt (info));
4178           bfd_put_32 (output_bfd, got_offset,
4179                       (splt->contents + h->plt.offset
4180                        + elf_sh_plt_symbol_offset (info)));
4181         }
4182
4183       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4184                   (splt->contents + h->plt.offset
4185                    + elf_sh_plt_reloc_offset (info)));
4186
4187       /* Fill in the entry in the global offset table.  */
4188       bfd_put_32 (output_bfd,
4189                   (splt->output_section->vma
4190                    + splt->output_offset
4191                    + h->plt.offset
4192                    + elf_sh_plt_temp_offset (info)),
4193                   sgot->contents + got_offset);
4194
4195       /* Fill in the entry in the .rela.plt section.  */
4196       rel.r_offset = (sgot->output_section->vma
4197                       + sgot->output_offset
4198                       + got_offset);
4199       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
4200       rel.r_addend = 0;
4201       bfd_elf32_swap_reloca_out (output_bfd, &rel,
4202                                 ((Elf32_External_Rela *) srel->contents
4203                                  + plt_index));
4204
4205       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4206         {
4207           /* Mark the symbol as undefined, rather than as defined in
4208              the .plt section.  Leave the value alone.  */
4209           sym->st_shndx = SHN_UNDEF;
4210         }
4211     }
4212
4213   if (h->got.offset != (bfd_vma) -1)
4214     {
4215       asection *sgot;
4216       asection *srel;
4217       Elf_Internal_Rela rel;
4218
4219       /* This symbol has an entry in the global offset table.  Set it
4220          up.  */
4221
4222       sgot = bfd_get_section_by_name (dynobj, ".got");
4223       srel = bfd_get_section_by_name (dynobj, ".rela.got");
4224       BFD_ASSERT (sgot != NULL && srel != NULL);
4225
4226       rel.r_offset = (sgot->output_section->vma
4227                       + sgot->output_offset
4228                       + (h->got.offset &~ 1));
4229
4230       /* If this is a -Bsymbolic link, and the symbol is defined
4231          locally, we just want to emit a RELATIVE reloc.  Likewise if
4232          the symbol was forced to be local because of a version file.
4233          The entry in the global offset table will already have been
4234          initialized in the relocate_section function.  */
4235       if (info->shared
4236           && (info->symbolic || h->dynindx == -1)
4237           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
4238         {
4239           rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4240           rel.r_addend = (h->root.u.def.value
4241                           + h->root.u.def.section->output_section->vma
4242                           + h->root.u.def.section->output_offset);
4243         }
4244       else
4245         {
4246           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4247           rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
4248           rel.r_addend = 0;
4249         }
4250
4251       bfd_elf32_swap_reloca_out (output_bfd, &rel,
4252                                  ((Elf32_External_Rela *) srel->contents
4253                                   + srel->reloc_count));
4254       ++srel->reloc_count;
4255     }
4256
4257   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4258     {
4259       asection *s;
4260       Elf_Internal_Rela rel;
4261
4262       /* This symbol needs a copy reloc.  Set it up.  */
4263
4264       BFD_ASSERT (h->dynindx != -1
4265                   && (h->root.type == bfd_link_hash_defined
4266                       || h->root.type == bfd_link_hash_defweak));
4267
4268       s = bfd_get_section_by_name (h->root.u.def.section->owner,
4269                                    ".rela.bss");
4270       BFD_ASSERT (s != NULL);
4271
4272       rel.r_offset = (h->root.u.def.value
4273                       + h->root.u.def.section->output_section->vma
4274                       + h->root.u.def.section->output_offset);
4275       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
4276       rel.r_addend = 0;
4277       bfd_elf32_swap_reloca_out (output_bfd, &rel,
4278                                  ((Elf32_External_Rela *) s->contents
4279                                   + s->reloc_count));
4280       ++s->reloc_count;
4281     }
4282
4283   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
4284   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4285       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
4286     sym->st_shndx = SHN_ABS;
4287
4288   return true;
4289 }
4290
4291 /* Finish up the dynamic sections.  */
4292
4293 static boolean
4294 sh_elf_finish_dynamic_sections (output_bfd, info)
4295      bfd *output_bfd;
4296      struct bfd_link_info *info;
4297 {
4298   bfd *dynobj;
4299   asection *sgot;
4300   asection *sdyn;
4301
4302   dynobj = elf_hash_table (info)->dynobj;
4303
4304   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4305   BFD_ASSERT (sgot != NULL);
4306   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4307
4308   if (elf_hash_table (info)->dynamic_sections_created)
4309     {
4310       asection *splt;
4311       Elf32_External_Dyn *dyncon, *dynconend;
4312
4313       BFD_ASSERT (sdyn != NULL);
4314
4315       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4316       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4317       for (; dyncon < dynconend; dyncon++)
4318         {
4319           Elf_Internal_Dyn dyn;
4320           const char *name;
4321           asection *s;
4322
4323           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4324
4325           switch (dyn.d_tag)
4326             {
4327             default:
4328               break;
4329
4330             case DT_PLTGOT:
4331               name = ".got";
4332               goto get_vma;
4333
4334             case DT_JMPREL:
4335               name = ".rela.plt";
4336             get_vma:
4337               s = bfd_get_section_by_name (output_bfd, name);
4338               BFD_ASSERT (s != NULL);
4339               dyn.d_un.d_ptr = s->vma;
4340               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4341               break;
4342
4343             case DT_PLTRELSZ:
4344               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4345               BFD_ASSERT (s != NULL);
4346               if (s->_cooked_size != 0)
4347                 dyn.d_un.d_val = s->_cooked_size;
4348               else
4349                 dyn.d_un.d_val = s->_raw_size;
4350               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4351               break;
4352
4353             case DT_RELASZ:
4354               /* My reading of the SVR4 ABI indicates that the
4355                  procedure linkage table relocs (DT_JMPREL) should be
4356                  included in the overall relocs (DT_RELA).  This is
4357                  what Solaris does.  However, UnixWare can not handle
4358                  that case.  Therefore, we override the DT_RELASZ entry
4359                  here to make it not include the JMPREL relocs.  Since
4360                  the linker script arranges for .rela.plt to follow all
4361                  other relocation sections, we don't have to worry
4362                  about changing the DT_RELA entry.  */
4363               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4364               if (s != NULL)
4365                 {
4366                   if (s->_cooked_size != 0)
4367                     dyn.d_un.d_val -= s->_cooked_size;
4368                   else
4369                     dyn.d_un.d_val -= s->_raw_size;
4370                 }
4371               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4372               break;
4373             }
4374         }
4375
4376       /* Fill in the first entry in the procedure linkage table.  */
4377       splt = bfd_get_section_by_name (dynobj, ".plt");
4378       if (splt && splt->_raw_size > 0)
4379         {
4380           if (info->shared)
4381             {
4382               if (elf_sh_pic_plt_entry == NULL)
4383                 {
4384                   elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
4385                                           elf_sh_pic_plt_entry_be :
4386                                           elf_sh_pic_plt_entry_le);
4387                 }
4388               memcpy (splt->contents, elf_sh_pic_plt_entry,
4389                       elf_sh_sizeof_plt (info));
4390             }
4391           else
4392             {
4393               if (elf_sh_plt0_entry == NULL)
4394                 {
4395                   elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
4396                                        elf_sh_plt0_entry_be :
4397                                        elf_sh_plt0_entry_le);
4398                 }
4399               memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
4400               bfd_put_32 (output_bfd,
4401                           sgot->output_section->vma + sgot->output_offset + 4,
4402                           splt->contents + elf_sh_plt0_gotid_offset (info));
4403               bfd_put_32 (output_bfd,
4404                           sgot->output_section->vma + sgot->output_offset + 8,
4405                           splt->contents + elf_sh_plt0_linker_offset (info));
4406             }
4407
4408           /* UnixWare sets the entsize of .plt to 4, although that doesn't
4409              really seem like the right value.  */
4410           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4411         }
4412     }
4413
4414   /* Fill in the first three entries in the global offset table.  */
4415   if (sgot->_raw_size > 0)
4416     {
4417       if (sdyn == NULL)
4418         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4419       else
4420         bfd_put_32 (output_bfd,
4421                     sdyn->output_section->vma + sdyn->output_offset,
4422                     sgot->contents);
4423       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4424       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4425     }
4426
4427   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4428
4429   return true;
4430 }
4431
4432 #ifndef ELF_ARCH
4433 #define TARGET_BIG_SYM          bfd_elf32_sh_vec
4434 #define TARGET_BIG_NAME         "elf32-sh"
4435 #define TARGET_LITTLE_SYM       bfd_elf32_shl_vec
4436 #define TARGET_LITTLE_NAME      "elf32-shl"
4437 #define ELF_ARCH                bfd_arch_sh
4438 #define ELF_MACHINE_CODE        EM_SH
4439 #define ELF_MAXPAGESIZE         128
4440
4441 #define elf_symbol_leading_char '_'
4442 #endif /* ELF_ARCH */
4443
4444 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
4445 #define elf_info_to_howto               sh_elf_info_to_howto
4446 #define bfd_elf32_bfd_relax_section     sh_elf_relax_section
4447 #define elf_backend_relocate_section    sh_elf_relocate_section
4448 #define bfd_elf32_bfd_get_relocated_section_contents \
4449                                         sh_elf_get_relocated_section_contents
4450 #define elf_backend_object_p            sh_elf_set_mach_from_flags
4451 #define bfd_elf32_bfd_set_private_bfd_flags \
4452                                         sh_elf_set_private_flags
4453 #define bfd_elf32_bfd_copy_private_bfd_data \
4454                                         sh_elf_copy_private_data
4455 #define bfd_elf32_bfd_merge_private_bfd_data \
4456                                         sh_elf_merge_private_data
4457
4458 #define elf_backend_gc_mark_hook        sh_elf_gc_mark_hook
4459 #define elf_backend_gc_sweep_hook       sh_elf_gc_sweep_hook
4460 #define elf_backend_check_relocs        sh_elf_check_relocs
4461
4462 #define elf_backend_can_gc_sections     1
4463 #define elf_backend_create_dynamic_sections \
4464                                         sh_elf_create_dynamic_sections
4465 #define bfd_elf32_bfd_link_hash_table_create \
4466                                         sh_elf_link_hash_table_create
4467 #define elf_backend_adjust_dynamic_symbol \
4468                                         sh_elf_adjust_dynamic_symbol
4469 #define elf_backend_size_dynamic_sections \
4470                                         sh_elf_size_dynamic_sections
4471 #define elf_backend_finish_dynamic_symbol \
4472                                         sh_elf_finish_dynamic_symbol
4473 #define elf_backend_finish_dynamic_sections \
4474                                         sh_elf_finish_dynamic_sections
4475
4476 #define elf_backend_want_got_plt        1
4477 #define elf_backend_plt_readonly        1
4478 #define elf_backend_want_plt_sym        0
4479 #define elf_backend_got_header_size     12
4480 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
4481 #include "elf32-target.h"