bfd/elf32-sh.c

   1 /* Hitachi SH specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
   3    Contributed by Ian Lance Taylor, Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/sh.h"
  27
  28 static bfd_reloc_status_type sh_elf_reloc
  29   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  30 static bfd_reloc_status_type sh_elf_ignore_reloc
  31   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  32 static reloc_howto_type *sh_elf_reloc_type_lookup
  33   PARAMS ((bfd *, bfd_reloc_code_real_type));
  34 static void sh_elf_info_to_howto
  35   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  36 static boolean sh_elf_relax_section
  37   PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
  38 static boolean sh_elf_relax_delete_bytes
  39   PARAMS ((bfd *, asection *, bfd_vma, int));
  40 static boolean sh_elf_align_loads
  41   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, boolean *));
  42 static boolean sh_elf_swap_insns
  43   PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
  44 static boolean sh_elf_relocate_section
  45   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  46            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  47 static bfd_byte *sh_elf_get_relocated_section_contents
  48   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
  49            bfd_byte *, boolean, asymbol **));
  50
  51 static reloc_howto_type sh_elf_howto_table[] =
  52 {
  53   /* No relocation.  */
  54   HOWTO (R_SH_NONE,             /* type */
  55          0,                     /* rightshift */
  56          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  57          0,                     /* bitsize */
  58          false,                 /* pc_relative */
  59          0,                     /* bitpos */
  60          complain_overflow_dont, /* complain_on_overflow */
  61          sh_elf_reloc,          /* special_function */
  62          "R_SH_NONE",           /* name */
  63          false,                 /* partial_inplace */
  64          0,                     /* src_mask */
  65          0,                     /* dst_mask */
  66          false),                /* pcrel_offset */
  67
  68   /* 32 bit absolute relocation.  Setting partial_inplace to true and
  69      src_mask to a non-zero value is similar to the COFF toolchain.  */
  70   HOWTO (R_SH_DIR32,            /* type */
  71          0,                     /* rightshift */
  72          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  73          32,                    /* bitsize */
  74          false,                 /* pc_relative */
  75          0,                     /* bitpos */
  76          complain_overflow_bitfield, /* complain_on_overflow */
  77          sh_elf_reloc,          /* special_function */
  78          "R_SH_DIR32",          /* name */
  79          true,                  /* partial_inplace */
  80          0xffffffff,            /* src_mask */
  81          0xffffffff,            /* dst_mask */
  82          false),                /* pcrel_offset */
  83
  84   /* 32 bit PC relative relocation.  */
  85   HOWTO (R_SH_REL32,            /* type */
  86          0,                     /* rightshift */
  87          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  88          32,                    /* bitsize */
  89          true,                  /* pc_relative */
  90          0,                     /* bitpos */
  91          complain_overflow_signed, /* complain_on_overflow */
  92          sh_elf_reloc,          /* special_function */
  93          "R_SH_REL32",          /* name */
  94          false,                 /* partial_inplace */
  95          0,                     /* src_mask */
  96          0xffffffff,            /* dst_mask */
  97          true),                 /* pcrel_offset */
  98
  99   /* 8 bit PC relative branch divided by 2.  */
 100   HOWTO (R_SH_DIR8WPN,          /* type */
 101          1,                     /* rightshift */
 102          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 103          8,                     /* bitsize */
 104          true,                  /* pc_relative */
 105          0,                     /* bitpos */
 106          complain_overflow_signed, /* complain_on_overflow */
 107          sh_elf_reloc,          /* special_function */
 108          "R_SH_DIR8WPN",        /* name */
 109          true,                  /* partial_inplace */
 110          0xff,                  /* src_mask */
 111          0xff,                  /* dst_mask */
 112          true),                 /* pcrel_offset */
 113
 114   /* 12 bit PC relative branch divided by 2.  */
 115   HOWTO (R_SH_IND12W,           /* type */
 116          1,                     /* rightshift */
 117          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 118          12,                    /* bitsize */
 119          true,                  /* pc_relative */
 120          0,                     /* bitpos */
 121          complain_overflow_signed, /* complain_on_overflow */
 122          sh_elf_reloc,          /* special_function */
 123          "R_SH_IND12W",         /* name */
 124          true,                  /* partial_inplace */
 125          0xfff,                 /* src_mask */
 126          0xfff,                 /* dst_mask */
 127          true),                 /* pcrel_offset */
 128
 129   /* 8 bit unsigned PC relative divided by 4.  */
 130   HOWTO (R_SH_DIR8WPL,          /* type */
 131          2,                     /* rightshift */
 132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 133          8,                     /* bitsize */
 134          true,                  /* pc_relative */
 135          0,                     /* bitpos */
 136          complain_overflow_unsigned, /* complain_on_overflow */
 137          sh_elf_reloc,          /* special_function */
 138          "R_SH_DIR8WPL",        /* name */
 139          true,                  /* partial_inplace */
 140          0xff,                  /* src_mask */
 141          0xff,                  /* dst_mask */
 142          true),                 /* pcrel_offset */
 143
 144   /* 8 bit unsigned PC relative divided by 2.  */
 145   HOWTO (R_SH_DIR8WPZ,          /* type */
 146          1,                     /* rightshift */
 147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 148          8,                     /* bitsize */
 149          true,                  /* pc_relative */
 150          0,                     /* bitpos */
 151          complain_overflow_unsigned, /* complain_on_overflow */
 152          sh_elf_reloc,          /* special_function */
 153          "R_SH_DIR8WPZ",        /* name */
 154          true,                  /* partial_inplace */
 155          0xff,                  /* src_mask */
 156          0xff,                  /* dst_mask */
 157          true),                 /* pcrel_offset */
 158
 159   /* 8 bit GBR relative.  FIXME: This only makes sense if we have some
 160      special symbol for the GBR relative area, and that is not
 161      implemented.  */
 162   HOWTO (R_SH_DIR8BP,           /* type */
 163          0,                     /* rightshift */
 164          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 165          8,                     /* bitsize */
 166          false,                 /* pc_relative */
 167          0,                     /* bitpos */
 168          complain_overflow_unsigned, /* complain_on_overflow */
 169          sh_elf_reloc,          /* special_function */
 170          "R_SH_DIR8BP",         /* name */
 171          false,                 /* partial_inplace */
 172          0,                     /* src_mask */
 173          0xff,                  /* dst_mask */
 174          true),                 /* pcrel_offset */
 175
 176   /* 8 bit GBR relative divided by 2.  FIXME: This only makes sense if
 177      we have some special symbol for the GBR relative area, and that
 178      is not implemented.  */
 179   HOWTO (R_SH_DIR8W,            /* type */
 180          1,                     /* rightshift */
 181          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 182          8,                     /* bitsize */
 183          false,                 /* pc_relative */
 184          0,                     /* bitpos */
 185          complain_overflow_unsigned, /* complain_on_overflow */
 186          sh_elf_reloc,          /* special_function */
 187          "R_SH_DIR8W",          /* name */
 188          false,                 /* partial_inplace */
 189          0,                     /* src_mask */
 190          0xff,                  /* dst_mask */
 191          true),                 /* pcrel_offset */
 192
 193   /* 8 bit GBR relative divided by 4.  FIXME: This only makes sense if
 194      we have some special symbol for the GBR relative area, and that
 195      is not implemented.  */
 196   HOWTO (R_SH_DIR8L,            /* type */
 197          2,                     /* rightshift */
 198          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 199          8,                     /* bitsize */
 200          false,                 /* pc_relative */
 201          0,                     /* bitpos */
 202          complain_overflow_unsigned, /* complain_on_overflow */
 203          sh_elf_reloc,          /* special_function */
 204          "R_SH_DIR8L",          /* name */
 205          false,                 /* partial_inplace */
 206          0,                     /* src_mask */
 207          0xff,                  /* dst_mask */
 208          true),                 /* pcrel_offset */
 209
 210   EMPTY_HOWTO (10),
 211   EMPTY_HOWTO (11),
 212   EMPTY_HOWTO (12),
 213   EMPTY_HOWTO (13),
 214   EMPTY_HOWTO (14),
 215   EMPTY_HOWTO (15),
 216   EMPTY_HOWTO (16),
 217   EMPTY_HOWTO (17),
 218   EMPTY_HOWTO (18),
 219   EMPTY_HOWTO (19),
 220   EMPTY_HOWTO (20),
 221   EMPTY_HOWTO (21),
 222   EMPTY_HOWTO (22),
 223   EMPTY_HOWTO (23),
 224   EMPTY_HOWTO (24),
 225
 226   /* The remaining relocs are a GNU extension used for relaxing.  The
 227      final pass of the linker never needs to do anything with any of
 228      these relocs.  Any required operations are handled by the
 229      relaxation code.  */
 230
 231   /* A 16 bit switch table entry.  This is generated for an expression
 232      such as ``.word L1 - L2''.  The offset holds the difference
 233      between the reloc address and L2.  */
 234   HOWTO (R_SH_SWITCH16,         /* type */
 235          0,                     /* rightshift */
 236          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 237          16,                    /* bitsize */
 238          false,                 /* pc_relative */
 239          0,                     /* bitpos */
 240          complain_overflow_unsigned, /* complain_on_overflow */
 241          sh_elf_ignore_reloc,   /* special_function */
 242          "R_SH_SWITCH16",       /* name */
 243          false,                 /* partial_inplace */
 244          0,                     /* src_mask */
 245          0,                     /* dst_mask */
 246          true),                 /* pcrel_offset */
 247
 248   /* A 32 bit switch table entry.  This is generated for an expression
 249      such as ``.long L1 - L2''.  The offset holds the difference
 250      between the reloc address and L2.  */
 251   HOWTO (R_SH_SWITCH32,         /* type */
 252          0,                     /* rightshift */
 253          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 254          32,                    /* bitsize */
 255          false,                 /* pc_relative */
 256          0,                     /* bitpos */
 257          complain_overflow_unsigned, /* complain_on_overflow */
 258          sh_elf_ignore_reloc,   /* special_function */
 259          "R_SH_SWITCH32",       /* name */
 260          false,                 /* partial_inplace */
 261          0,                     /* src_mask */
 262          0,                     /* dst_mask */
 263          true),                 /* pcrel_offset */
 264
 265   /* Indicates a .uses pseudo-op.  The compiler will generate .uses
 266      pseudo-ops when it finds a function call which can be relaxed.
 267      The offset field holds the PC relative offset to the instruction
 268      which loads the register used in the function call.  */
 269   HOWTO (R_SH_USES,             /* type */
 270          0,                     /* rightshift */
 271          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          0,                     /* bitsize */
 273          false,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_unsigned, /* complain_on_overflow */
 276          sh_elf_ignore_reloc,   /* special_function */
 277          "R_SH_USES",           /* name */
 278          false,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0,                     /* dst_mask */
 281          true),                 /* pcrel_offset */
 282
 283   /* The assembler will generate this reloc for addresses referred to
 284      by the register loads associated with USES relocs.  The offset
 285      field holds the number of times the address is referenced in the
 286      object file.  */
 287   HOWTO (R_SH_COUNT,            /* type */
 288          0,                     /* rightshift */
 289          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 290          0,                     /* bitsize */
 291          false,                 /* pc_relative */
 292          0,                     /* bitpos */
 293          complain_overflow_unsigned, /* complain_on_overflow */
 294          sh_elf_ignore_reloc,   /* special_function */
 295          "R_SH_COUNT",          /* name */
 296          false,                 /* partial_inplace */
 297          0,                     /* src_mask */
 298          0,                     /* dst_mask */
 299          true),                 /* pcrel_offset */
 300
 301   /* Indicates an alignment statement.  The offset field is the power
 302      of 2 to which subsequent portions of the object file must be
 303      aligned.  */
 304   HOWTO (R_SH_ALIGN,            /* type */
 305          0,                     /* rightshift */
 306          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 307          0,                     /* bitsize */
 308          false,                 /* pc_relative */
 309          0,                     /* bitpos */
 310          complain_overflow_unsigned, /* complain_on_overflow */
 311          sh_elf_ignore_reloc,   /* special_function */
 312          "R_SH_ALIGN",  /* name */
 313          false,                 /* partial_inplace */
 314          0,                     /* src_mask */
 315          0,                     /* dst_mask */
 316          true),                 /* pcrel_offset */
 317
 318   /* The assembler will generate this reloc before a block of
 319      instructions.  A section should be processed as assumining it
 320      contains data, unless this reloc is seen.  */
 321   HOWTO (R_SH_CODE,             /* type */
 322          0,                     /* rightshift */
 323          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 324          0,                     /* bitsize */
 325          false,                 /* pc_relative */
 326          0,                     /* bitpos */
 327          complain_overflow_unsigned, /* complain_on_overflow */
 328          sh_elf_ignore_reloc,   /* special_function */
 329          "R_SH_CODE",           /* name */
 330          false,                 /* partial_inplace */
 331          0,                     /* src_mask */
 332          0,                     /* dst_mask */
 333          true),                 /* pcrel_offset */
 334
 335   /* The assembler will generate this reloc after a block of
 336      instructions when it sees data that is not instructions.  */
 337   HOWTO (R_SH_DATA,             /* type */
 338          0,                     /* rightshift */
 339          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 340          0,                     /* bitsize */
 341          false,                 /* pc_relative */
 342          0,                     /* bitpos */
 343          complain_overflow_unsigned, /* complain_on_overflow */
 344          sh_elf_ignore_reloc,   /* special_function */
 345          "R_SH_DATA",           /* name */
 346          false,                 /* partial_inplace */
 347          0,                     /* src_mask */
 348          0,                     /* dst_mask */
 349          true),                 /* pcrel_offset */
 350
 351   /* The assembler generates this reloc for each label within a block
 352      of instructions.  This permits the linker to avoid swapping
 353      instructions which are the targets of branches.  */
 354   HOWTO (R_SH_LABEL,            /* type */
 355          0,                     /* rightshift */
 356          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          0,                     /* bitsize */
 358          false,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_unsigned, /* complain_on_overflow */
 361          sh_elf_ignore_reloc,   /* special_function */
 362          "R_SH_LABEL",          /* name */
 363          false,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0,                     /* dst_mask */
 366          true),                 /* pcrel_offset */
 367
 368   /* An 8 bit switch table entry.  This is generated for an expression
 369      such as ``.word L1 - L2''.  The offset holds the difference
 370      between the reloc address and L2.  */
 371   HOWTO (R_SH_SWITCH8,          /* type */
 372          0,                     /* rightshift */
 373          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 374          8,                     /* bitsize */
 375          false,                 /* pc_relative */
 376          0,                     /* bitpos */
 377          complain_overflow_unsigned, /* complain_on_overflow */
 378          sh_elf_ignore_reloc,   /* special_function */
 379          "R_SH_SWITCH8",        /* name */
 380          false,                 /* partial_inplace */
 381          0,                     /* src_mask */
 382          0,                     /* dst_mask */
 383          true),                 /* pcrel_offset */
 384
 385   /* GNU extension to record C++ vtable hierarchy */
 386   HOWTO (R_SH_GNU_VTINHERIT, /* type */
 387          0,                     /* rightshift */
 388          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 389          0,                     /* bitsize */
 390          false,                 /* pc_relative */
 391          0,                     /* bitpos */
 392          complain_overflow_dont, /* complain_on_overflow */
 393          NULL,                  /* special_function */
 394          "R_SH_GNU_VTINHERIT", /* name */
 395          false,                 /* partial_inplace */
 396          0,                     /* src_mask */
 397          0,                     /* dst_mask */
 398          false),                /* pcrel_offset */
 399
 400   /* GNU extension to record C++ vtable member usage */
 401   HOWTO (R_SH_GNU_VTENTRY,     /* type */
 402          0,                     /* rightshift */
 403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          0,                     /* bitsize */
 405          false,                 /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_dont, /* complain_on_overflow */
 408          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 409          "R_SH_GNU_VTENTRY",   /* name */
 410          false,                 /* partial_inplace */
 411          0,                     /* src_mask */
 412          0,                     /* dst_mask */
 413          false),                /* pcrel_offset */
 414
 415 };
 416
 417 /* This function is used for normal relocs.  This is like the COFF
 418    function, and is almost certainly incorrect for other ELF targets.  */
 419
 420 static bfd_reloc_status_type
 421 sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
 422           error_message)
 423      bfd *abfd;
 424      arelent *reloc_entry;
 425      asymbol *symbol_in;
 426      PTR data;
 427      asection *input_section;
 428      bfd *output_bfd;
 429      char **error_message ATTRIBUTE_UNUSED;
 430 {
 431   unsigned long insn;
 432   bfd_vma sym_value;
 433   enum elf_sh_reloc_type r_type;
 434   bfd_vma addr = reloc_entry->address;
 435   bfd_byte *hit_data = addr + (bfd_byte *) data;
 436
 437   r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
 438
 439   if (output_bfd != NULL)
 440     {
 441       /* Partial linking--do nothing.  */
 442       reloc_entry->address += input_section->output_offset;
 443       return bfd_reloc_ok;
 444     }
 445
 446   /* Almost all relocs have to do with relaxing.  If any work must be
 447      done for them, it has been done in sh_relax_section.  */
 448   if (r_type != R_SH_DIR32
 449       && (r_type != R_SH_IND12W
 450           || (symbol_in->flags & BSF_LOCAL) != 0))
 451     return bfd_reloc_ok;
 452
 453   if (symbol_in != NULL
 454       && bfd_is_und_section (symbol_in->section))
 455     return bfd_reloc_undefined;
 456
 457   if (bfd_is_com_section (symbol_in->section))
 458     sym_value = 0;
 459   else
 460     sym_value = (symbol_in->value +
 461                  symbol_in->section->output_section->vma +
 462                  symbol_in->section->output_offset);
 463
 464   switch (r_type)
 465     {
 466     case R_SH_DIR32:
 467       insn = bfd_get_32 (abfd, hit_data);
 468       insn += sym_value + reloc_entry->addend;
 469       bfd_put_32 (abfd, insn, hit_data);
 470       break;
 471     case R_SH_IND12W:
 472       insn = bfd_get_16 (abfd, hit_data);
 473       sym_value += reloc_entry->addend;
 474       sym_value -= (input_section->output_section->vma
 475                     + input_section->output_offset
 476                     + addr
 477                     + 4);
 478       sym_value += (insn & 0xfff) << 1;
 479       if (insn & 0x800)
 480         sym_value -= 0x1000;
 481       insn = (insn & 0xf000) | (sym_value & 0xfff);
 482       bfd_put_16 (abfd, insn, hit_data);
 483       if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
 484         return bfd_reloc_overflow;
 485       break;
 486     default:
 487       abort ();
 488       break;
 489     }
 490
 491   return bfd_reloc_ok;
 492 }
 493
 494 /* This function is used for relocs which are only used for relaxing,
 495    which the linker should otherwise ignore.  */
 496
 497 static bfd_reloc_status_type
 498 sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
 499                      output_bfd, error_message)
 500      bfd *abfd ATTRIBUTE_UNUSED;
 501      arelent *reloc_entry;
 502      asymbol *symbol ATTRIBUTE_UNUSED;
 503      PTR data ATTRIBUTE_UNUSED;
 504      asection *input_section;
 505      bfd *output_bfd;
 506      char **error_message ATTRIBUTE_UNUSED;
 507 {
 508   if (output_bfd != NULL)
 509     reloc_entry->address += input_section->output_offset;
 510   return bfd_reloc_ok;
 511 }
 512
 513 /* This structure is used to map BFD reloc codes to SH ELF relocs.  */
 514
 515 struct elf_reloc_map
 516 {
 517   bfd_reloc_code_real_type bfd_reloc_val;
 518   unsigned char elf_reloc_val;
 519 };
 520
 521 /* An array mapping BFD reloc codes to SH ELF relocs.  */
 522
 523 static const struct elf_reloc_map sh_reloc_map[] =
 524 {
 525   { BFD_RELOC_NONE, R_SH_NONE },
 526   { BFD_RELOC_32, R_SH_DIR32 },
 527   { BFD_RELOC_CTOR, R_SH_DIR32 },
 528   { BFD_RELOC_32_PCREL, R_SH_REL32 },
 529   { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
 530   { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
 531   { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
 532   { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
 533   { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
 534   { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
 535   { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
 536   { BFD_RELOC_SH_USES, R_SH_USES },
 537   { BFD_RELOC_SH_COUNT, R_SH_COUNT },
 538   { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
 539   { BFD_RELOC_SH_CODE, R_SH_CODE },
 540   { BFD_RELOC_SH_DATA, R_SH_DATA },
 541   { BFD_RELOC_SH_LABEL, R_SH_LABEL },
 542   { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
 543   { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
 544 };
 545
 546 /* Given a BFD reloc code, return the howto structure for the
 547    corresponding SH ELf reloc.  */
 548
 549 static reloc_howto_type *
 550 sh_elf_reloc_type_lookup (abfd, code)
 551      bfd *abfd ATTRIBUTE_UNUSED;
 552      bfd_reloc_code_real_type code;
 553 {
 554   unsigned int i;
 555
 556   for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
 557     {
 558       if (sh_reloc_map[i].bfd_reloc_val == code)
 559         return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
 560     }
 561
 562   return NULL;
 563 }
 564
 565 /* Given an ELF reloc, fill in the howto field of a relent.  */
 566
 567 static void
 568 sh_elf_info_to_howto (abfd, cache_ptr, dst)
 569      bfd *abfd ATTRIBUTE_UNUSED;
 570      arelent *cache_ptr;
 571      Elf_Internal_Rela *dst;
 572 {
 573   unsigned int r;
 574
 575   r = ELF32_R_TYPE (dst->r_info);
 576
 577   BFD_ASSERT (r < (unsigned int) R_SH_max);
 578   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
 579
 580   cache_ptr->howto = &sh_elf_howto_table[r];
 581 }
 582 \f
 583 /* This function handles relaxing for SH ELF.  See the corresponding
 584    function in coff-sh.c for a description of what this does.  FIXME:
 585    There is a lot of duplication here between this code and the COFF
 586    specific code.  The format of relocs and symbols is wound deeply
 587    into this code, but it would still be better if the duplication
 588    could be eliminated somehow.  Note in particular that although both
 589    functions use symbols like R_SH_CODE, those symbols have different
 590    values; in coff-sh.c they come from include/coff/sh.h, whereas here
 591    they come from enum elf_sh_reloc_type in include/elf/sh.h.  */
 592
 593 static boolean
 594 sh_elf_relax_section (abfd, sec, link_info, again)
 595      bfd *abfd;
 596      asection *sec;
 597      struct bfd_link_info *link_info;
 598      boolean *again;
 599 {
 600   Elf_Internal_Shdr *symtab_hdr;
 601   Elf_Internal_Rela *internal_relocs;
 602   Elf_Internal_Rela *free_relocs = NULL;
 603   boolean have_code;
 604   Elf_Internal_Rela *irel, *irelend;
 605   bfd_byte *contents = NULL;
 606   bfd_byte *free_contents = NULL;
 607   Elf32_External_Sym *extsyms = NULL;
 608   Elf32_External_Sym *free_extsyms = NULL;
 609
 610   *again = false;
 611
 612   if (link_info->relocateable
 613       || (sec->flags & SEC_RELOC) == 0
 614       || sec->reloc_count == 0)
 615     return true;
 616
 617   /* If this is the first time we have been called for this section,
 618      initialize the cooked size.  */
 619   if (sec->_cooked_size == 0)
 620     sec->_cooked_size = sec->_raw_size;
 621
 622   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 623
 624   internal_relocs = (_bfd_elf32_link_read_relocs
 625                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
 626                       link_info->keep_memory));
 627   if (internal_relocs == NULL)
 628     goto error_return;
 629   if (! link_info->keep_memory)
 630     free_relocs = internal_relocs;
 631
 632   have_code = false;
 633
 634   irelend = internal_relocs + sec->reloc_count;
 635   for (irel = internal_relocs; irel < irelend; irel++)
 636     {
 637       bfd_vma laddr, paddr, symval;
 638       unsigned short insn;
 639       Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
 640       bfd_signed_vma foff;
 641
 642       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
 643         have_code = true;
 644
 645       if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
 646         continue;
 647
 648       /* Get the section contents.  */
 649       if (contents == NULL)
 650         {
 651           if (elf_section_data (sec)->this_hdr.contents != NULL)
 652             contents = elf_section_data (sec)->this_hdr.contents;
 653           else
 654             {
 655               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 656               if (contents == NULL)
 657                 goto error_return;
 658               free_contents = contents;
 659
 660               if (! bfd_get_section_contents (abfd, sec, contents,
 661                                               (file_ptr) 0, sec->_raw_size))
 662                 goto error_return;
 663             }
 664         }
 665
 666       /* The r_addend field of the R_SH_USES reloc will point us to
 667          the register load.  The 4 is because the r_addend field is
 668          computed as though it were a jump offset, which are based
 669          from 4 bytes after the jump instruction.  */
 670       laddr = irel->r_offset + 4 + irel->r_addend;
 671       if (laddr >= sec->_raw_size)
 672         {
 673           (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
 674                                  bfd_get_filename (abfd),
 675                                  (unsigned long) irel->r_offset);
 676           continue;
 677         }
 678       insn = bfd_get_16 (abfd, contents + laddr);
 679
 680       /* If the instruction is not mov.l NN,rN, we don't know what to
 681          do.  */
 682       if ((insn & 0xf000) != 0xd000)
 683         {
 684           ((*_bfd_error_handler)
 685            (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
 686             bfd_get_filename (abfd), (unsigned long) irel->r_offset, insn));
 687           continue;
 688         }
 689
 690       /* Get the address from which the register is being loaded.  The
 691          displacement in the mov.l instruction is quadrupled.  It is a
 692          displacement from four bytes after the movl instruction, but,
 693          before adding in the PC address, two least significant bits
 694          of the PC are cleared.  We assume that the section is aligned
 695          on a four byte boundary.  */
 696       paddr = insn & 0xff;
 697       paddr *= 4;
 698       paddr += (laddr + 4) &~ 3;
 699       if (paddr >= sec->_raw_size)
 700         {
 701           ((*_bfd_error_handler)
 702            (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
 703             bfd_get_filename (abfd), (unsigned long) irel->r_offset));
 704           continue;
 705         }
 706
 707       /* Get the reloc for the address from which the register is
 708          being loaded.  This reloc will tell us which function is
 709          actually being called.  */
 710       for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
 711         if (irelfn->r_offset == paddr
 712             && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
 713           break;
 714       if (irelfn >= irelend)
 715         {
 716           ((*_bfd_error_handler)
 717            (_("%s: 0x%lx: warning: could not find expected reloc"),
 718             bfd_get_filename (abfd), (unsigned long) paddr));
 719           continue;
 720         }
 721
 722       /* Read this BFD's symbols if we haven't done so already.  */
 723       if (extsyms == NULL)
 724         {
 725           if (symtab_hdr->contents != NULL)
 726             extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
 727           else
 728             {
 729               extsyms = ((Elf32_External_Sym *)
 730                          bfd_malloc (symtab_hdr->sh_size));
 731               if (extsyms == NULL)
 732                 goto error_return;
 733               free_extsyms = extsyms;
 734               if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
 735                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
 736                       != symtab_hdr->sh_size))
 737                 goto error_return;
 738             }
 739         }
 740
 741       /* Get the value of the symbol referred to by the reloc.  */
 742       if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
 743         {
 744           Elf_Internal_Sym isym;
 745
 746           /* A local symbol.  */
 747           bfd_elf32_swap_symbol_in (abfd,
 748                                     extsyms + ELF32_R_SYM (irelfn->r_info),
 749                                     &isym);
 750
 751           if (isym.st_shndx != _bfd_elf_section_from_bfd_section (abfd, sec))
 752             {
 753               ((*_bfd_error_handler)
 754                (_("%s: 0x%lx: warning: symbol in unexpected section"),
 755                 bfd_get_filename (abfd), (unsigned long) paddr));
 756               continue;
 757             }
 758
 759           symval = (isym.st_value
 760                     + sec->output_section->vma
 761                     + sec->output_offset);
 762         }
 763       else
 764         {
 765           unsigned long indx;
 766           struct elf_link_hash_entry *h;
 767
 768           indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
 769           h = elf_sym_hashes (abfd)[indx];
 770           BFD_ASSERT (h != NULL);
 771           if (h->root.type != bfd_link_hash_defined
 772               && h->root.type != bfd_link_hash_defweak)
 773             {
 774               /* This appears to be a reference to an undefined
 775                  symbol.  Just ignore it--it will be caught by the
 776                  regular reloc processing.  */
 777               continue;
 778             }
 779
 780           symval = (h->root.u.def.value
 781                     + h->root.u.def.section->output_section->vma
 782                     + h->root.u.def.section->output_offset);
 783         }
 784
 785       symval += bfd_get_32 (abfd, contents + paddr);
 786
 787       /* See if this function call can be shortened.  */
 788       foff = (symval
 789               - (irel->r_offset
 790                  + sec->output_section->vma
 791                  + sec->output_offset
 792                  + 4));
 793       if (foff < -0x1000 || foff >= 0x1000)
 794         {
 795           /* After all that work, we can't shorten this function call.  */
 796           continue;
 797         }
 798
 799       /* Shorten the function call.  */
 800
 801       /* For simplicity of coding, we are going to modify the section
 802          contents, the section relocs, and the BFD symbol table.  We
 803          must tell the rest of the code not to free up this
 804          information.  It would be possible to instead create a table
 805          of changes which have to be made, as is done in coff-mips.c;
 806          that would be more work, but would require less memory when
 807          the linker is run.  */
 808
 809       elf_section_data (sec)->relocs = internal_relocs;
 810       free_relocs = NULL;
 811
 812       elf_section_data (sec)->this_hdr.contents = contents;
 813       free_contents = NULL;
 814
 815       symtab_hdr->contents = (bfd_byte *) extsyms;
 816       free_extsyms = NULL;
 817
 818       /* Replace the jsr with a bsr.  */
 819
 820       /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
 821          replace the jsr with a bsr.  */
 822       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
 823       if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
 824         {
 825           /* If this needs to be changed because of future relaxing,
 826              it will be handled here like other internal IND12W
 827              relocs.  */
 828           bfd_put_16 (abfd,
 829                       0xb000 | ((foff >> 1) & 0xfff),
 830                       contents + irel->r_offset);
 831         }
 832       else
 833         {
 834           /* We can't fully resolve this yet, because the external
 835              symbol value may be changed by future relaxing.  We let
 836              the final link phase handle it.  */
 837           bfd_put_16 (abfd, 0xb000, contents + irel->r_offset);
 838         }
 839
 840       /* See if there is another R_SH_USES reloc referring to the same
 841          register load.  */
 842       for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
 843         if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
 844             && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
 845           break;
 846       if (irelscan < irelend)
 847         {
 848           /* Some other function call depends upon this register load,
 849              and we have not yet converted that function call.
 850              Indeed, we may never be able to convert it.  There is
 851              nothing else we can do at this point.  */
 852           continue;
 853         }
 854
 855       /* Look for a R_SH_COUNT reloc on the location where the
 856          function address is stored.  Do this before deleting any
 857          bytes, to avoid confusion about the address.  */
 858       for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
 859         if (irelcount->r_offset == paddr
 860             && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
 861           break;
 862
 863       /* Delete the register load.  */
 864       if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
 865         goto error_return;
 866
 867       /* That will change things, so, just in case it permits some
 868          other function call to come within range, we should relax
 869          again.  Note that this is not required, and it may be slow.  */
 870       *again = true;
 871
 872       /* Now check whether we got a COUNT reloc.  */
 873       if (irelcount >= irelend)
 874         {
 875           ((*_bfd_error_handler)
 876            (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
 877             bfd_get_filename (abfd), (unsigned long) paddr));
 878           continue;
 879         }
 880
 881       /* The number of uses is stored in the r_addend field.  We've
 882          just deleted one.  */
 883       if (irelcount->r_addend == 0)
 884         {
 885           ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
 886                                   bfd_get_filename (abfd),
 887                                   (unsigned long) paddr));
 888           continue;
 889         }
 890
 891       --irelcount->r_addend;
 892
 893       /* If there are no more uses, we can delete the address.  Reload
 894          the address from irelfn, in case it was changed by the
 895          previous call to sh_elf_relax_delete_bytes.  */
 896       if (irelcount->r_addend == 0)
 897         {
 898           if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
 899             goto error_return;
 900         }
 901
 902       /* We've done all we can with that function call.  */
 903     }
 904
 905   /* Look for load and store instructions that we can align on four
 906      byte boundaries.  */
 907   if (have_code)
 908     {
 909       boolean swapped;
 910
 911       /* Get the section contents.  */
 912       if (contents == NULL)
 913         {
 914           if (elf_section_data (sec)->this_hdr.contents != NULL)
 915             contents = elf_section_data (sec)->this_hdr.contents;
 916           else
 917             {
 918               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 919               if (contents == NULL)
 920                 goto error_return;
 921               free_contents = contents;
 922
 923               if (! bfd_get_section_contents (abfd, sec, contents,
 924                                               (file_ptr) 0, sec->_raw_size))
 925                 goto error_return;
 926             }
 927         }
 928
 929       if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
 930                                 &swapped))
 931         goto error_return;
 932
 933       if (swapped)
 934         {
 935           elf_section_data (sec)->relocs = internal_relocs;
 936           free_relocs = NULL;
 937
 938           elf_section_data (sec)->this_hdr.contents = contents;
 939           free_contents = NULL;
 940
 941           symtab_hdr->contents = (bfd_byte *) extsyms;
 942           free_extsyms = NULL;
 943         }
 944     }
 945
 946   if (free_relocs != NULL)
 947     {
 948       free (free_relocs);
 949       free_relocs = NULL;
 950     }
 951
 952   if (free_contents != NULL)
 953     {
 954       if (! link_info->keep_memory)
 955         free (free_contents);
 956       else
 957         {
 958           /* Cache the section contents for elf_link_input_bfd.  */
 959           elf_section_data (sec)->this_hdr.contents = contents;
 960         }
 961       free_contents = NULL;
 962     }
 963
 964   if (free_extsyms != NULL)
 965     {
 966       if (! link_info->keep_memory)
 967         free (free_extsyms);
 968       else
 969         {
 970           /* Cache the symbols for elf_link_input_bfd.  */
 971           symtab_hdr->contents = extsyms;
 972         }
 973       free_extsyms = NULL;
 974     }
 975
 976   return true;
 977
 978  error_return:
 979   if (free_relocs != NULL)
 980     free (free_relocs);
 981   if (free_contents != NULL)
 982     free (free_contents);
 983   if (free_extsyms != NULL)
 984     free (free_extsyms);
 985   return false;
 986 }
 987
 988 /* Delete some bytes from a section while relaxing.  FIXME: There is a
 989    lot of duplication between this function and sh_relax_delete_bytes
 990    in coff-sh.c.  */
 991
 992 static boolean
 993 sh_elf_relax_delete_bytes (abfd, sec, addr, count)
 994      bfd *abfd;
 995      asection *sec;
 996      bfd_vma addr;
 997      int count;
 998 {
 999   Elf_Internal_Shdr *symtab_hdr;
1000   Elf32_External_Sym *extsyms;
1001   int shndx, index;
1002   bfd_byte *contents;
1003   Elf_Internal_Rela *irel, *irelend;
1004   Elf_Internal_Rela *irelalign;
1005   bfd_vma toaddr;
1006   Elf32_External_Sym *esym, *esymend;
1007   struct elf_link_hash_entry *sym_hash;
1008   asection *o;
1009
1010   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1011   extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1012
1013   shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1014
1015   contents = elf_section_data (sec)->this_hdr.contents;
1016
1017   /* The deletion must stop at the next ALIGN reloc for an aligment
1018      power larger than the number of bytes we are deleting.  */
1019
1020   irelalign = NULL;
1021   toaddr = sec->_cooked_size;
1022
1023   irel = elf_section_data (sec)->relocs;
1024   irelend = irel + sec->reloc_count;
1025   for (; irel < irelend; irel++)
1026     {
1027       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1028           && irel->r_offset > addr
1029           && count < (1 << irel->r_addend))
1030         {
1031           irelalign = irel;
1032           toaddr = irel->r_offset;
1033           break;
1034         }
1035     }
1036
1037   /* Actually delete the bytes.  */
1038   memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1039   if (irelalign == NULL)
1040     sec->_cooked_size -= count;
1041   else
1042     {
1043       int i;
1044
1045 #define NOP_OPCODE (0x0009)
1046
1047       BFD_ASSERT ((count & 1) == 0);
1048       for (i = 0; i < count; i += 2)
1049         bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i);
1050     }
1051
1052   /* Adjust all the relocs.  */
1053   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1054     {
1055       bfd_vma nraddr, stop;
1056       bfd_vma start = 0;
1057       int insn = 0;
1058       Elf_Internal_Sym sym;
1059       int off, adjust, oinsn;
1060       bfd_signed_vma voff = 0;
1061       boolean overflow;
1062
1063       /* Get the new reloc address.  */
1064       nraddr = irel->r_offset;
1065       if ((irel->r_offset > addr
1066            && irel->r_offset < toaddr)
1067           || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1068               && irel->r_offset == toaddr))
1069         nraddr -= count;
1070
1071       /* See if this reloc was for the bytes we have deleted, in which
1072          case we no longer care about it.  Don't delete relocs which
1073          represent addresses, though.  */
1074       if (irel->r_offset >= addr
1075           && irel->r_offset < addr + count
1076           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
1077           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
1078           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
1079           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
1080         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1081                                      (int) R_SH_NONE);
1082
1083       /* If this is a PC relative reloc, see if the range it covers
1084          includes the bytes we have deleted.  */
1085       switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1086         {
1087         default:
1088           break;
1089
1090         case R_SH_DIR8WPN:
1091         case R_SH_IND12W:
1092         case R_SH_DIR8WPZ:
1093         case R_SH_DIR8WPL:
1094           start = irel->r_offset;
1095           insn = bfd_get_16 (abfd, contents + nraddr);
1096           break;
1097         }
1098
1099       switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1100         {
1101         default:
1102           start = stop = addr;
1103           break;
1104
1105         case R_SH_DIR32:
1106           /* If this reloc is against a symbol defined in this
1107              section, and the symbol will not be adjusted below, we
1108              must check the addend to see it will put the value in
1109              range to be adjusted, and hence must be changed.  */
1110           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1111             {
1112               bfd_elf32_swap_symbol_in (abfd,
1113                                         extsyms + ELF32_R_SYM (irel->r_info),
1114                                         &sym);
1115               if (sym.st_shndx == shndx
1116                   && (sym.st_value <= addr
1117                       || sym.st_value >= toaddr))
1118                 {
1119                   bfd_vma val;
1120
1121                   val = bfd_get_32 (abfd, contents + nraddr);
1122                   val += sym.st_value;
1123                   if (val > addr && val < toaddr)
1124                     bfd_put_32 (abfd, val - count, contents + nraddr);
1125                 }
1126             }
1127           start = stop = addr;
1128           break;
1129
1130         case R_SH_DIR8WPN:
1131           off = insn & 0xff;
1132           if (off & 0x80)
1133             off -= 0x100;
1134           stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1135           break;
1136
1137         case R_SH_IND12W:
1138           if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
1139             start = stop = addr;
1140           else
1141             {
1142               off = insn & 0xfff;
1143               if (off & 0x800)
1144                 off -= 0x1000;
1145               stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1146             }
1147           break;
1148
1149         case R_SH_DIR8WPZ:
1150           off = insn & 0xff;
1151           stop = start + 4 + off * 2;
1152           break;
1153
1154         case R_SH_DIR8WPL:
1155           off = insn & 0xff;
1156           stop = (start &~ (bfd_vma) 3) + 4 + off * 4;
1157           break;
1158
1159         case R_SH_SWITCH8:
1160         case R_SH_SWITCH16:
1161         case R_SH_SWITCH32:
1162           /* These relocs types represent
1163                .word L2-L1
1164              The r_addend field holds the difference between the reloc
1165              address and L1.  That is the start of the reloc, and
1166              adding in the contents gives us the top.  We must adjust
1167              both the r_offset field and the section contents.
1168              N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1169              and the elf bfd r_offset is called r_vaddr.  */
1170
1171           stop = irel->r_offset;
1172           start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1173
1174           if (start > addr
1175               && start < toaddr
1176               && (stop <= addr || stop >= toaddr))
1177             irel->r_addend += count;
1178           else if (stop > addr
1179                    && stop < toaddr
1180                    && (start <= addr || start >= toaddr))
1181             irel->r_addend -= count;
1182
1183           if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1184             voff = bfd_get_signed_16 (abfd, contents + nraddr);
1185           else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1186             voff = bfd_get_8 (abfd, contents + nraddr);
1187           else
1188             voff = bfd_get_signed_32 (abfd, contents + nraddr);
1189           stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1190
1191           break;
1192
1193         case R_SH_USES:
1194           start = irel->r_offset;
1195           stop = (bfd_vma) ((bfd_signed_vma) start
1196                             + (long) irel->r_addend
1197                             + 4);
1198           break;
1199         }
1200
1201       if (start > addr
1202           && start < toaddr
1203           && (stop <= addr || stop >= toaddr))
1204         adjust = count;
1205       else if (stop > addr
1206                && stop < toaddr
1207                && (start <= addr || start >= toaddr))
1208         adjust = - count;
1209       else
1210         adjust = 0;
1211
1212       if (adjust != 0)
1213         {
1214           oinsn = insn;
1215           overflow = false;
1216           switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1217             {
1218             default:
1219               abort ();
1220               break;
1221
1222             case R_SH_DIR8WPN:
1223             case R_SH_DIR8WPZ:
1224               insn += adjust / 2;
1225               if ((oinsn & 0xff00) != (insn & 0xff00))
1226                 overflow = true;
1227               bfd_put_16 (abfd, insn, contents + nraddr);
1228               break;
1229
1230             case R_SH_IND12W:
1231               insn += adjust / 2;
1232               if ((oinsn & 0xf000) != (insn & 0xf000))
1233                 overflow = true;
1234               bfd_put_16 (abfd, insn, contents + nraddr);
1235               break;
1236
1237             case R_SH_DIR8WPL:
1238               BFD_ASSERT (adjust == count || count >= 4);
1239               if (count >= 4)
1240                 insn += adjust / 4;
1241               else
1242                 {
1243                   if ((irel->r_offset & 3) == 0)
1244                     ++insn;
1245                 }
1246               if ((oinsn & 0xff00) != (insn & 0xff00))
1247                 overflow = true;
1248               bfd_put_16 (abfd, insn, contents + nraddr);
1249               break;
1250
1251             case R_SH_SWITCH16:
1252               voff += adjust;
1253               if (voff < - 0x8000 || voff >= 0x8000)
1254                 overflow = true;
1255               bfd_put_signed_16 (abfd, voff, contents + nraddr);
1256               break;
1257
1258             case R_SH_SWITCH32:
1259               voff += adjust;
1260               bfd_put_signed_32 (abfd, voff, contents + nraddr);
1261               break;
1262
1263             case R_SH_USES:
1264               irel->r_addend += adjust;
1265               break;
1266             }
1267
1268           if (overflow)
1269             {
1270               ((*_bfd_error_handler)
1271                (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1272                 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1273               bfd_set_error (bfd_error_bad_value);
1274               return false;
1275             }
1276         }
1277
1278       irel->r_offset = nraddr;
1279     }
1280
1281   /* Look through all the other sections.  If there contain any IMM32
1282      relocs against internal symbols which we are not going to adjust
1283      below, we may need to adjust the addends.  */
1284   for (o = abfd->sections; o != NULL; o = o->next)
1285     {
1286       Elf_Internal_Rela *internal_relocs;
1287       Elf_Internal_Rela *irelscan, *irelscanend;
1288       bfd_byte *ocontents;
1289
1290       if (o == sec
1291           || (o->flags & SEC_RELOC) == 0
1292           || o->reloc_count == 0)
1293         continue;
1294
1295       /* We always cache the relocs.  Perhaps, if info->keep_memory is
1296          false, we should free them, if we are permitted to, when we
1297          leave sh_coff_relax_section.  */
1298       internal_relocs = (_bfd_elf32_link_read_relocs
1299                          (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1300                           true));
1301       if (internal_relocs == NULL)
1302         return false;
1303
1304       ocontents = NULL;
1305       irelscanend = internal_relocs + o->reloc_count;
1306       for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1307         {
1308           Elf_Internal_Sym sym;
1309
1310           /* Dwarf line numbers use R_SH_SWITCH32 relocs.  */
1311           if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1312             {
1313               bfd_vma start, stop;
1314               bfd_signed_vma voff;
1315
1316               if (ocontents == NULL)
1317                 {
1318                   if (elf_section_data (o)->this_hdr.contents != NULL)
1319                     ocontents = elf_section_data (o)->this_hdr.contents;
1320                   else
1321                     {
1322                       /* We always cache the section contents.
1323                          Perhaps, if info->keep_memory is false, we
1324                          should free them, if we are permitted to,
1325                          when we leave sh_coff_relax_section.  */
1326                       ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1327                       if (ocontents == NULL)
1328                         return false;
1329                       if (! bfd_get_section_contents (abfd, o, ocontents,
1330                                                       (file_ptr) 0,
1331                                                       o->_raw_size))
1332                         return false;
1333                       elf_section_data (o)->this_hdr.contents = ocontents;
1334                     }
1335                 }
1336
1337               stop = irelscan->r_offset;
1338               start
1339                 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1340
1341               /* STOP is in a different section, so it won't change.  */
1342               if (start > addr && start < toaddr)
1343                 irelscan->r_addend += count;
1344
1345               voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1346               stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1347
1348               if (start > addr
1349                   && start < toaddr
1350                   && (stop <= addr || stop >= toaddr))
1351                 bfd_put_signed_32 (abfd, voff + count,
1352                                    ocontents + irelscan->r_offset);
1353               else if (stop > addr
1354                        && stop < toaddr
1355                        && (start <= addr || start >= toaddr))
1356                 bfd_put_signed_32 (abfd, voff - count,
1357                                    ocontents + irelscan->r_offset);
1358             }
1359
1360           if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1361             continue;
1362
1363           if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1364             continue;
1365
1366           bfd_elf32_swap_symbol_in (abfd,
1367                                     extsyms + ELF32_R_SYM (irelscan->r_info),
1368                                     &sym);
1369
1370           if (sym.st_shndx == shndx
1371               && (sym.st_value <= addr
1372                   || sym.st_value >= toaddr))
1373             {
1374               bfd_vma val;
1375
1376               if (ocontents == NULL)
1377                 {
1378                   if (elf_section_data (o)->this_hdr.contents != NULL)
1379                     ocontents = elf_section_data (o)->this_hdr.contents;
1380                   else
1381                     {
1382                       /* We always cache the section contents.
1383                          Perhaps, if info->keep_memory is false, we
1384                          should free them, if we are permitted to,
1385                          when we leave sh_coff_relax_section.  */
1386                       ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1387                       if (ocontents == NULL)
1388                         return false;
1389                       if (! bfd_get_section_contents (abfd, o, ocontents,
1390                                                       (file_ptr) 0,
1391                                                       o->_raw_size))
1392                         return false;
1393                       elf_section_data (o)->this_hdr.contents = ocontents;
1394                     }
1395                 }
1396
1397               val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1398               val += sym.st_value;
1399               if (val > addr && val < toaddr)
1400                 bfd_put_32 (abfd, val - count,
1401                             ocontents + irelscan->r_offset);
1402             }
1403         }
1404     }
1405
1406   /* Adjust the local symbols defined in this section.  */
1407   esym = extsyms;
1408   esymend = esym + symtab_hdr->sh_info;
1409   for (; esym < esymend; esym++)
1410     {
1411       Elf_Internal_Sym isym;
1412
1413       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1414
1415       if (isym.st_shndx == shndx
1416           && isym.st_value > addr
1417           && isym.st_value < toaddr)
1418         {
1419           isym.st_value -= count;
1420           bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1421         }
1422     }
1423
1424   /* Now adjust the global symbols defined in this section.  */
1425   esym = extsyms + symtab_hdr->sh_info;
1426   esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1427   for (index = 0; esym < esymend; esym++, index++)
1428     {
1429       Elf_Internal_Sym isym;
1430
1431       bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1432       sym_hash = elf_sym_hashes (abfd)[index];
1433       if (isym.st_shndx == shndx
1434           && ((sym_hash)->root.type == bfd_link_hash_defined
1435               || (sym_hash)->root.type == bfd_link_hash_defweak)
1436           && (sym_hash)->root.u.def.section == sec
1437           && (sym_hash)->root.u.def.value > addr
1438           && (sym_hash)->root.u.def.value < toaddr)
1439         {
1440           (sym_hash)->root.u.def.value -= count;
1441         }
1442     }
1443
1444   /* See if we can move the ALIGN reloc forward.  We have adjusted
1445      r_offset for it already.  */
1446   if (irelalign != NULL)
1447     {
1448       bfd_vma alignto, alignaddr;
1449
1450       alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1451       alignaddr = BFD_ALIGN (irelalign->r_offset,
1452                              1 << irelalign->r_addend);
1453       if (alignto != alignaddr)
1454         {
1455           /* Tail recursion.  */
1456           return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1457                                             alignto - alignaddr);
1458         }
1459     }
1460
1461   return true;
1462 }
1463
1464 /* Look for loads and stores which we can align to four byte
1465    boundaries.  This is like sh_align_loads in coff-sh.c.  */
1466
1467 static boolean
1468 sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
1469      bfd *abfd;
1470      asection *sec;
1471      Elf_Internal_Rela *internal_relocs;
1472      bfd_byte *contents;
1473      boolean *pswapped;
1474 {
1475   Elf_Internal_Rela *irel, *irelend;
1476   bfd_vma *labels = NULL;
1477   bfd_vma *label, *label_end;
1478
1479   *pswapped = false;
1480
1481   irelend = internal_relocs + sec->reloc_count;
1482
1483   /* Get all the addresses with labels on them.  */
1484   labels = (bfd_vma *) bfd_malloc (sec->reloc_count * sizeof (bfd_vma));
1485   if (labels == NULL)
1486     goto error_return;
1487   label_end = labels;
1488   for (irel = internal_relocs; irel < irelend; irel++)
1489     {
1490       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1491         {
1492           *label_end = irel->r_offset;
1493           ++label_end;
1494         }
1495     }
1496
1497   /* Note that the assembler currently always outputs relocs in
1498      address order.  If that ever changes, this code will need to sort
1499      the label values and the relocs.  */
1500
1501   label = labels;
1502
1503   for (irel = internal_relocs; irel < irelend; irel++)
1504     {
1505       bfd_vma start, stop;
1506
1507       if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1508         continue;
1509
1510       start = irel->r_offset;
1511
1512       for (irel++; irel < irelend; irel++)
1513         if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1514           break;
1515       if (irel < irelend)
1516         stop = irel->r_offset;
1517       else
1518         stop = sec->_cooked_size;
1519
1520       if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1521                                      (PTR) internal_relocs, &label,
1522                                      label_end, start, stop, pswapped))
1523         goto error_return;
1524     }
1525
1526   free (labels);
1527
1528   return true;
1529
1530  error_return:
1531   if (labels != NULL)
1532     free (labels);
1533   return false;
1534 }
1535
1536 /* Swap two SH instructions.  This is like sh_swap_insns in coff-sh.c.  */
1537
1538 static boolean
1539 sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
1540      bfd *abfd;
1541      asection *sec;
1542      PTR relocs;
1543      bfd_byte *contents;
1544      bfd_vma addr;
1545 {
1546   Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1547   unsigned short i1, i2;
1548   Elf_Internal_Rela *irel, *irelend;
1549
1550   /* Swap the instructions themselves.  */
1551   i1 = bfd_get_16 (abfd, contents + addr);
1552   i2 = bfd_get_16 (abfd, contents + addr + 2);
1553   bfd_put_16 (abfd, i2, contents + addr);
1554   bfd_put_16 (abfd, i1, contents + addr + 2);
1555
1556   /* Adjust all reloc addresses.  */
1557   irelend = internal_relocs + sec->reloc_count;
1558   for (irel = internal_relocs; irel < irelend; irel++)
1559     {
1560       enum elf_sh_reloc_type type;
1561       int add;
1562
1563       /* There are a few special types of relocs that we don't want to
1564          adjust.  These relocs do not apply to the instruction itself,
1565          but are only associated with the address.  */
1566       type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1567       if (type == R_SH_ALIGN
1568           || type == R_SH_CODE
1569           || type == R_SH_DATA
1570           || type == R_SH_LABEL)
1571         continue;
1572
1573       /* If an R_SH_USES reloc points to one of the addresses being
1574          swapped, we must adjust it.  It would be incorrect to do this
1575          for a jump, though, since we want to execute both
1576          instructions after the jump.  (We have avoided swapping
1577          around a label, so the jump will not wind up executing an
1578          instruction it shouldn't).  */
1579       if (type == R_SH_USES)
1580         {
1581           bfd_vma off;
1582
1583           off = irel->r_offset + 4 + irel->r_addend;
1584           if (off == addr)
1585             irel->r_offset += 2;
1586           else if (off == addr + 2)
1587             irel->r_offset -= 2;
1588         }
1589
1590       if (irel->r_offset == addr)
1591         {
1592           irel->r_offset += 2;
1593           add = -2;
1594         }
1595       else if (irel->r_offset == addr + 2)
1596         {
1597           irel->r_offset -= 2;
1598           add = 2;
1599         }
1600       else
1601         add = 0;
1602
1603       if (add != 0)
1604         {
1605           bfd_byte *loc;
1606           unsigned short insn, oinsn;
1607           boolean overflow;
1608
1609           loc = contents + irel->r_offset;
1610           overflow = false;
1611           switch (type)
1612             {
1613             default:
1614               break;
1615
1616             case R_SH_DIR8WPN:
1617             case R_SH_DIR8WPZ:
1618               insn = bfd_get_16 (abfd, loc);
1619               oinsn = insn;
1620               insn += add / 2;
1621               if ((oinsn & 0xff00) != (insn & 0xff00))
1622                 overflow = true;
1623               bfd_put_16 (abfd, insn, loc);
1624               break;
1625
1626             case R_SH_IND12W:
1627               insn = bfd_get_16 (abfd, loc);
1628               oinsn = insn;
1629               insn += add / 2;
1630               if ((oinsn & 0xf000) != (insn & 0xf000))
1631                 overflow = true;
1632               bfd_put_16 (abfd, insn, loc);
1633               break;
1634
1635             case R_SH_DIR8WPL:
1636               /* This reloc ignores the least significant 3 bits of
1637                  the program counter before adding in the offset.
1638                  This means that if ADDR is at an even address, the
1639                  swap will not affect the offset.  If ADDR is an at an
1640                  odd address, then the instruction will be crossing a
1641                  four byte boundary, and must be adjusted.  */
1642               if ((addr & 3) != 0)
1643                 {
1644                   insn = bfd_get_16 (abfd, loc);
1645                   oinsn = insn;
1646                   insn += add / 2;
1647                   if ((oinsn & 0xff00) != (insn & 0xff00))
1648                     overflow = true;
1649                   bfd_put_16 (abfd, insn, loc);
1650                 }
1651
1652               break;
1653             }
1654
1655           if (overflow)
1656             {
1657               ((*_bfd_error_handler)
1658                (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1659                 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1660               bfd_set_error (bfd_error_bad_value);
1661               return false;
1662             }
1663         }
1664     }
1665
1666   return true;
1667 }
1668 \f
1669 /* Relocate an SH ELF section.  */
1670
1671 static boolean
1672 sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1673                          contents, relocs, local_syms, local_sections)
1674      bfd *output_bfd ATTRIBUTE_UNUSED;
1675      struct bfd_link_info *info;
1676      bfd *input_bfd;
1677      asection *input_section;
1678      bfd_byte *contents;
1679      Elf_Internal_Rela *relocs;
1680      Elf_Internal_Sym *local_syms;
1681      asection **local_sections;
1682 {
1683   Elf_Internal_Shdr *symtab_hdr;
1684   struct elf_link_hash_entry **sym_hashes;
1685   Elf_Internal_Rela *rel, *relend;
1686
1687   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1688   sym_hashes = elf_sym_hashes (input_bfd);
1689
1690   rel = relocs;
1691   relend = relocs + input_section->reloc_count;
1692   for (; rel < relend; rel++)
1693     {
1694       int r_type;
1695       reloc_howto_type *howto;
1696       unsigned long r_symndx;
1697       Elf_Internal_Sym *sym;
1698       asection *sec;
1699       struct elf_link_hash_entry *h;
1700       bfd_vma relocation;
1701       bfd_vma addend = (bfd_vma)0;
1702       bfd_reloc_status_type r;
1703
1704       r_symndx = ELF32_R_SYM (rel->r_info);
1705
1706       if (info->relocateable)
1707         {
1708           /* This is a relocateable link.  We don't have to change
1709              anything, unless the reloc is against a section symbol,
1710              in which case we have to adjust according to where the
1711              section symbol winds up in the output section.  */
1712           if (r_symndx < symtab_hdr->sh_info)
1713             {
1714               sym = local_syms + r_symndx;
1715               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1716                 {
1717                   sec = local_sections[r_symndx];
1718                   rel->r_addend += sec->output_offset + sym->st_value;
1719                 }
1720             }
1721
1722           continue;
1723         }
1724
1725       r_type = ELF32_R_TYPE (rel->r_info);
1726
1727       /* Many of the relocs are only used for relaxing, and are
1728          handled entirely by the relaxation code.  */
1729       if (r_type > (int) R_SH_LAST_INVALID_RELOC)
1730         continue;
1731
1732       if (r_type < 0
1733           || r_type >= (int) R_SH_FIRST_INVALID_RELOC)
1734         {
1735           bfd_set_error (bfd_error_bad_value);
1736           return false;
1737         }
1738
1739       /* FIXME: This is certainly incorrect.  However, it is how the
1740          COFF linker works.  */
1741       if (r_type != (int) R_SH_DIR32
1742           && r_type != (int) R_SH_IND12W)
1743         continue;
1744
1745       howto = sh_elf_howto_table + r_type;
1746
1747       /* This is a final link.  */
1748       h = NULL;
1749       sym = NULL;
1750       sec = NULL;
1751       if (r_symndx < symtab_hdr->sh_info)
1752         {
1753           /* There is nothing to be done for an internal IND12W
1754              relocation.  FIXME: This is probably wrong, but it's how
1755              the COFF relocations work.  */
1756           if (r_type == (int) R_SH_IND12W)
1757             continue;
1758           sym = local_syms + r_symndx;
1759           sec = local_sections[r_symndx];
1760           relocation = (sec->output_section->vma
1761                         + sec->output_offset
1762                         + sym->st_value);
1763         }
1764       else
1765         {
1766           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1767           while (h->root.type == bfd_link_hash_indirect
1768                  || h->root.type == bfd_link_hash_warning)
1769             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1770           if (h->root.type == bfd_link_hash_defined
1771               || h->root.type == bfd_link_hash_defweak)
1772             {
1773               sec = h->root.u.def.section;
1774               relocation = (h->root.u.def.value
1775                             + sec->output_section->vma
1776                             + sec->output_offset);
1777             }
1778           else if (h->root.type == bfd_link_hash_undefweak)
1779             relocation = 0;
1780           else
1781             {
1782               if (! ((*info->callbacks->undefined_symbol)
1783                      (info, h->root.root.string, input_bfd,
1784                       input_section, rel->r_offset)))
1785                 return false;
1786               relocation = 0;
1787             }
1788         }
1789
1790       /* FIXME: This is how the COFF relocations work.  */
1791       if (r_type == (int) R_SH_IND12W)
1792         relocation -= 4;
1793
1794       switch ((int)r_type)
1795         {
1796         case (int)R_SH_DIR32:
1797           addend = rel->r_addend;
1798           break;
1799         }
1800
1801       /* COFF relocs don't use the addend. The addend is used for R_SH_DIR32
1802          to be compatible with other compilers. */
1803       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1804                                     contents, rel->r_offset,
1805                                     relocation, addend);
1806
1807       if (r != bfd_reloc_ok)
1808         {
1809           switch (r)
1810             {
1811             default:
1812             case bfd_reloc_outofrange:
1813               abort ();
1814             case bfd_reloc_overflow:
1815               {
1816                 const char *name;
1817
1818                 if (h != NULL)
1819                   name = h->root.root.string;
1820                 else
1821                   {
1822                     name = (bfd_elf_string_from_elf_section
1823                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
1824                     if (name == NULL)
1825                       return false;
1826                     if (*name == '\0')
1827                       name = bfd_section_name (input_bfd, sec);
1828                   }
1829                 if (! ((*info->callbacks->reloc_overflow)
1830                        (info, name, howto->name, (bfd_vma) 0,
1831                         input_bfd, input_section, rel->r_offset)))
1832                   return false;
1833               }
1834               break;
1835             }
1836         }
1837     }
1838
1839   return true;
1840 }
1841
1842 /* This is a version of bfd_generic_get_relocated_section_contents
1843    which uses sh_elf_relocate_section.  */
1844
1845 static bfd_byte *
1846 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1847                                         data, relocateable, symbols)
1848      bfd *output_bfd;
1849      struct bfd_link_info *link_info;
1850      struct bfd_link_order *link_order;
1851      bfd_byte *data;
1852      boolean relocateable;
1853      asymbol **symbols;
1854 {
1855   Elf_Internal_Shdr *symtab_hdr;
1856   asection *input_section = link_order->u.indirect.section;
1857   bfd *input_bfd = input_section->owner;
1858   asection **sections = NULL;
1859   Elf_Internal_Rela *internal_relocs = NULL;
1860   Elf32_External_Sym *external_syms = NULL;
1861   Elf_Internal_Sym *internal_syms = NULL;
1862
1863   /* We only need to handle the case of relaxing, or of having a
1864      particular set of section contents, specially.  */
1865   if (relocateable
1866       || elf_section_data (input_section)->this_hdr.contents == NULL)
1867     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1868                                                        link_order, data,
1869                                                        relocateable,
1870                                                        symbols);
1871
1872   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1873
1874   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1875           input_section->_raw_size);
1876
1877   if ((input_section->flags & SEC_RELOC) != 0
1878       && input_section->reloc_count > 0)
1879     {
1880       Elf_Internal_Sym *isymp;
1881       asection **secpp;
1882       Elf32_External_Sym *esym, *esymend;
1883
1884       if (symtab_hdr->contents != NULL)
1885         external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
1886       else
1887         {
1888           external_syms = ((Elf32_External_Sym *)
1889                            bfd_malloc (symtab_hdr->sh_info
1890                                        * sizeof (Elf32_External_Sym)));
1891           if (external_syms == NULL && symtab_hdr->sh_info > 0)
1892             goto error_return;
1893           if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1894               || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
1895                             symtab_hdr->sh_info, input_bfd)
1896                   != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
1897             goto error_return;
1898         }
1899
1900       internal_relocs = (_bfd_elf32_link_read_relocs
1901                          (input_bfd, input_section, (PTR) NULL,
1902                           (Elf_Internal_Rela *) NULL, false));
1903       if (internal_relocs == NULL)
1904         goto error_return;
1905
1906       internal_syms = ((Elf_Internal_Sym *)
1907                        bfd_malloc (symtab_hdr->sh_info
1908                                    * sizeof (Elf_Internal_Sym)));
1909       if (internal_syms == NULL && symtab_hdr->sh_info > 0)
1910         goto error_return;
1911
1912       sections = (asection **) bfd_malloc (symtab_hdr->sh_info
1913                                            * sizeof (asection *));
1914       if (sections == NULL && symtab_hdr->sh_info > 0)
1915         goto error_return;
1916
1917       isymp = internal_syms;
1918       secpp = sections;
1919       esym = external_syms;
1920       esymend = esym + symtab_hdr->sh_info;
1921       for (; esym < esymend; ++esym, ++isymp, ++secpp)
1922         {
1923           asection *isec;
1924
1925           bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
1926
1927           if (isymp->st_shndx == SHN_UNDEF)
1928             isec = bfd_und_section_ptr;
1929           else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
1930             isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
1931           else if (isymp->st_shndx == SHN_ABS)
1932             isec = bfd_abs_section_ptr;
1933           else if (isymp->st_shndx == SHN_COMMON)
1934             isec = bfd_com_section_ptr;
1935           else
1936             {
1937               /* Who knows?  */
1938               isec = NULL;
1939             }
1940
1941           *secpp = isec;
1942         }
1943
1944       if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
1945                                      input_section, data, internal_relocs,
1946                                      internal_syms, sections))
1947         goto error_return;
1948
1949       if (sections != NULL)
1950         free (sections);
1951       sections = NULL;
1952       if (internal_syms != NULL)
1953         free (internal_syms);
1954       internal_syms = NULL;
1955       if (external_syms != NULL && symtab_hdr->contents == NULL)
1956         free (external_syms);
1957       external_syms = NULL;
1958       if (internal_relocs != elf_section_data (input_section)->relocs)
1959         free (internal_relocs);
1960       internal_relocs = NULL;
1961     }
1962
1963   return data;
1964
1965  error_return:
1966   if (internal_relocs != NULL
1967       && internal_relocs != elf_section_data (input_section)->relocs)
1968     free (internal_relocs);
1969   if (external_syms != NULL && symtab_hdr->contents == NULL)
1970     free (external_syms);
1971   if (internal_syms != NULL)
1972     free (internal_syms);
1973   if (sections != NULL)
1974     free (sections);
1975   return NULL;
1976 }
1977 static asection *
1978 sh_elf_gc_mark_hook (abfd, info, rel, h, sym)
1979        bfd *abfd;
1980        struct bfd_link_info *info ATTRIBUTE_UNUSED;
1981        Elf_Internal_Rela *rel;
1982        struct elf_link_hash_entry *h;
1983        Elf_Internal_Sym *sym;
1984 {
1985   if (h != NULL)
1986     {
1987       switch (ELF32_R_TYPE (rel->r_info))
1988       {
1989       case R_SH_GNU_VTINHERIT:
1990       case R_SH_GNU_VTENTRY:
1991         break;
1992
1993       default:
1994         switch (h->root.type)
1995           {
1996           case bfd_link_hash_defined:
1997           case bfd_link_hash_defweak:
1998             return h->root.u.def.section;
1999
2000           case bfd_link_hash_common:
2001             return h->root.u.c.p->section;
2002
2003           default:
2004             break;
2005           }
2006        }
2007      }
2008    else
2009      {
2010        if (!(elf_bad_symtab (abfd)
2011            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2012          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2013                 && sym->st_shndx != SHN_COMMON))
2014           {
2015             return bfd_section_from_elf_index (abfd, sym->st_shndx);
2016           }
2017       }
2018   return NULL;
2019 }
2020
2021 static boolean
2022 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
2023      bfd *abfd ATTRIBUTE_UNUSED;
2024      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2025      asection *sec ATTRIBUTE_UNUSED;
2026      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2027 {
2028   /* we don't use got and plt entries for sh. */
2029   return true;
2030 }
2031
2032 /* Look through the relocs for a section during the first phase.
2033    Since we don't do .gots or .plts, we just need to consider the
2034    virtual table relocs for gc.  */
2035
2036 static boolean
2037 sh_elf_check_relocs (abfd, info, sec, relocs)
2038      bfd *abfd;
2039      struct bfd_link_info *info;
2040      asection *sec;
2041      const Elf_Internal_Rela *relocs;
2042 {
2043   Elf_Internal_Shdr *symtab_hdr;
2044   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2045   const Elf_Internal_Rela *rel;
2046   const Elf_Internal_Rela *rel_end;
2047
2048   if (info->relocateable)
2049     return true;
2050
2051   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2052   sym_hashes = elf_sym_hashes (abfd);
2053   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
2054   if (!elf_bad_symtab (abfd))
2055     sym_hashes_end -= symtab_hdr->sh_info;
2056
2057   rel_end = relocs + sec->reloc_count;
2058   for (rel = relocs; rel < rel_end; rel++)
2059     {
2060       struct elf_link_hash_entry *h;
2061       unsigned long r_symndx;
2062
2063       r_symndx = ELF32_R_SYM (rel->r_info);
2064       if (r_symndx < symtab_hdr->sh_info)
2065         h = NULL;
2066       else
2067         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2068
2069       switch (ELF32_R_TYPE (rel->r_info))
2070         {
2071         /* This relocation describes the C++ object vtable hierarchy.
2072            Reconstruct it for later use during GC.  */
2073         case R_SH_GNU_VTINHERIT:
2074           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2075             return false;
2076           break;
2077
2078         /* This relocation describes which C++ vtable entries are actually
2079            used.  Record for later use during GC.  */
2080         case R_SH_GNU_VTENTRY:
2081           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2082             return false;
2083           break;
2084         }
2085     }
2086
2087   return true;
2088 }
2089
2090 #define TARGET_BIG_SYM          bfd_elf32_sh_vec
2091 #define TARGET_BIG_NAME         "elf32-sh"
2092 #define TARGET_LITTLE_SYM       bfd_elf32_shl_vec
2093 #define TARGET_LITTLE_NAME      "elf32-shl"
2094 #define ELF_ARCH                bfd_arch_sh
2095 #define ELF_MACHINE_CODE        EM_SH
2096 #define ELF_MAXPAGESIZE         0x1
2097
2098 #define elf_symbol_leading_char '_'
2099
2100 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
2101 #define elf_info_to_howto               sh_elf_info_to_howto
2102 #define bfd_elf32_bfd_relax_section     sh_elf_relax_section
2103 #define elf_backend_relocate_section    sh_elf_relocate_section
2104 #define bfd_elf32_bfd_get_relocated_section_contents \
2105                                         sh_elf_get_relocated_section_contents
2106 #define bfd_elf32_bfd_merge_private_bfd_data \
2107                                         _bfd_generic_verify_endian_match
2108
2109 #define elf_backend_gc_mark_hook        sh_elf_gc_mark_hook
2110 #define elf_backend_gc_sweep_hook       sh_elf_gc_sweep_hook
2111 #define elf_backend_check_relocs        sh_elf_check_relocs
2112
2113 #define elf_backend_can_gc_sections 1
2114 #include "elf32-target.h"