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