bfd/elf32-sh.c

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