bfd/coff-sh.c

   1 /* BFD back-end for Hitachi Super-H COFF binaries.
   2    Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4    Written by Steve Chamberlain, <sac@cygnus.com>.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "obstack.h"
  25 #include "libbfd.h"
  26 #include "bfdlink.h"
  27 #include "coff/sh.h"
  28 #include "coff/internal.h"
  29 #include "libcoff.h"
  30
  31 /* Internal functions.  */
  32 static bfd_reloc_status_type sh_reloc
  33   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  34 static long get_symbol_value PARAMS ((asymbol *));
  35 static boolean sh_relax_section
  36   PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
  37 static boolean sh_relax_delete_bytes
  38   PARAMS ((bfd *, asection *, bfd_vma, int));
  39 static boolean sh_relocate_section
  40   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  41            struct internal_reloc *, struct internal_syment *, asection **));
  42 static bfd_byte *sh_coff_get_relocated_section_contents
  43   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
  44            bfd_byte *, boolean, asymbol **));
  45
  46 /* Default section alignment to 2**2.  */
  47 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
  48
  49 /* Generate long file names.  */
  50 #define COFF_LONG_FILENAMES
  51
  52 /* The supported relocations.  There are a lot of relocations defined
  53    in coff/internal.h which we do not expect to ever see.  */
  54 static reloc_howto_type sh_coff_howtos[] =
  55 {
  56   { 0 },
  57   { 1 },
  58   { 2 },
  59   { 3 }, /* R_SH_PCREL8 */
  60   { 4 }, /* R_SH_PCREL16 */
  61   { 5 }, /* R_SH_HIGH8 */
  62   { 6 }, /* R_SH_IMM24 */
  63   { 7 }, /* R_SH_LOW16 */
  64   { 8 },
  65   { 9 }, /* R_SH_PCDISP8BY4 */
  66
  67   HOWTO (R_SH_PCDISP8BY2,       /* type */
  68          1,                     /* rightshift */
  69          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  70          8,                     /* bitsize */
  71          true,                  /* pc_relative */
  72          0,                     /* bitpos */
  73          complain_overflow_signed, /* complain_on_overflow */
  74          sh_reloc,              /* special_function */
  75          "r_pcdisp8by2",        /* name */
  76          true,                  /* partial_inplace */
  77          0xff,                  /* src_mask */
  78          0xff,                  /* dst_mask */
  79          true),                 /* pcrel_offset */
  80
  81   { 11 }, /* R_SH_PCDISP8 */
  82
  83   HOWTO (R_SH_PCDISP,           /* type */
  84          1,                     /* rightshift */
  85          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  86          12,                    /* bitsize */
  87          true,                  /* pc_relative */
  88          0,                     /* bitpos */
  89          complain_overflow_signed, /* complain_on_overflow */
  90          sh_reloc,              /* special_function */
  91          "r_pcdisp12by2",       /* name */
  92          true,                  /* partial_inplace */
  93          0xfff,                 /* src_mask */
  94          0xfff,                 /* dst_mask */
  95          true),                 /* pcrel_offset */
  96
  97   { 13 },
  98
  99   HOWTO (R_SH_IMM32,            /* type */
 100          0,                     /* rightshift */
 101          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 102          32,                    /* bitsize */
 103          false,                 /* pc_relative */
 104          0,                     /* bitpos */
 105          complain_overflow_bitfield, /* complain_on_overflow */
 106          sh_reloc,              /* special_function */
 107          "r_imm32",             /* name */
 108          true,                  /* partial_inplace */
 109          0xffffffff,            /* src_mask */
 110          0xffffffff,            /* dst_mask */
 111          false),                /* pcrel_offset */
 112
 113   { 15 },
 114   { 16 }, /* R_SH_IMM8 */
 115   { 17 }, /* R_SH_IMM8BY2 */
 116   { 18 }, /* R_SH_IMM8BY4 */
 117   { 19 }, /* R_SH_IMM4 */
 118   { 20 }, /* R_SH_IMM4BY2 */
 119   { 21 }, /* R_SH_IMM4BY4 */
 120
 121   HOWTO (R_SH_PCRELIMM8BY2,     /* type */
 122          1,                     /* rightshift */
 123          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 124          8,                     /* bitsize */
 125          true,                  /* pc_relative */
 126          0,                     /* bitpos */
 127          complain_overflow_unsigned, /* complain_on_overflow */
 128          sh_reloc,              /* special_function */
 129          "r_pcrelimm8by2",      /* name */
 130          true,                  /* partial_inplace */
 131          0xff,                  /* src_mask */
 132          0xff,                  /* dst_mask */
 133          true),                 /* pcrel_offset */
 134
 135   HOWTO (R_SH_PCRELIMM8BY4,     /* type */
 136          2,                     /* rightshift */
 137          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 138          8,                     /* bitsize */
 139          true,                  /* pc_relative */
 140          0,                     /* bitpos */
 141          complain_overflow_unsigned, /* complain_on_overflow */
 142          sh_reloc,              /* special_function */
 143          "r_pcrelimm8by4",      /* name */
 144          true,                  /* partial_inplace */
 145          0xff,                  /* src_mask */
 146          0xff,                  /* dst_mask */
 147          true),                 /* pcrel_offset */
 148
 149   HOWTO (R_SH_IMM16,            /* type */
 150          0,                     /* rightshift */
 151          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 152          16,                    /* bitsize */
 153          false,                 /* pc_relative */
 154          0,                     /* bitpos */
 155          complain_overflow_bitfield, /* complain_on_overflow */
 156          sh_reloc,              /* special_function */
 157          "r_imm16",             /* name */
 158          true,                  /* partial_inplace */
 159          0xffff,                /* src_mask */
 160          0xffff,                /* dst_mask */
 161          false),                /* pcrel_offset */
 162
 163   HOWTO (R_SH_SWITCH16,         /* type */
 164          0,                     /* rightshift */
 165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 166          16,                    /* bitsize */
 167          false,                 /* pc_relative */
 168          0,                     /* bitpos */
 169          complain_overflow_bitfield, /* complain_on_overflow */
 170          sh_reloc,              /* special_function */
 171          "r_switch16",          /* name */
 172          true,                  /* partial_inplace */
 173          0xffff,                /* src_mask */
 174          0xffff,                /* dst_mask */
 175          false),                /* pcrel_offset */
 176
 177   HOWTO (R_SH_SWITCH32,         /* type */
 178          0,                     /* rightshift */
 179          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 180          32,                    /* bitsize */
 181          false,                 /* pc_relative */
 182          0,                     /* bitpos */
 183          complain_overflow_bitfield, /* complain_on_overflow */
 184          sh_reloc,              /* special_function */
 185          "r_switch32",          /* name */
 186          true,                  /* partial_inplace */
 187          0xffffffff,            /* src_mask */
 188          0xffffffff,            /* dst_mask */
 189          false),                /* pcrel_offset */
 190
 191   HOWTO (R_SH_USES,             /* type */
 192          0,                     /* rightshift */
 193          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 194          16,                    /* bitsize */
 195          false,                 /* pc_relative */
 196          0,                     /* bitpos */
 197          complain_overflow_bitfield, /* complain_on_overflow */
 198          sh_reloc,              /* special_function */
 199          "r_uses",              /* name */
 200          true,                  /* partial_inplace */
 201          0xffff,                /* src_mask */
 202          0xffff,                /* dst_mask */
 203          false),                /* pcrel_offset */
 204
 205   HOWTO (R_SH_COUNT,            /* type */
 206          0,                     /* rightshift */
 207          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 208          32,                    /* bitsize */
 209          false,                 /* pc_relative */
 210          0,                     /* bitpos */
 211          complain_overflow_bitfield, /* complain_on_overflow */
 212          sh_reloc,              /* special_function */
 213          "r_count",             /* name */
 214          true,                  /* partial_inplace */
 215          0xffffffff,            /* src_mask */
 216          0xffffffff,            /* dst_mask */
 217          false),                /* pcrel_offset */
 218
 219   HOWTO (R_SH_ALIGN,            /* type */
 220          0,                     /* rightshift */
 221          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 222          32,                    /* bitsize */
 223          false,                 /* pc_relative */
 224          0,                     /* bitpos */
 225          complain_overflow_bitfield, /* complain_on_overflow */
 226          sh_reloc,              /* special_function */
 227          "r_align",             /* name */
 228          true,                  /* partial_inplace */
 229          0xffffffff,            /* src_mask */
 230          0xffffffff,            /* dst_mask */
 231          false)                 /* pcrel_offset */
 232 };
 233
 234 #define SH_COFF_HOWTO_COUNT (sizeof sh_coff_howtos / sizeof sh_coff_howtos[0])
 235
 236 /* Check for a bad magic number.  */
 237 #define BADMAG(x) SHBADMAG(x)
 238
 239 /* Customize coffcode.h (this is not currently used).  */
 240 #define SH 1
 241
 242 /* FIXME: This should not be set here.  */
 243 #define __A_MAGIC_SET__
 244
 245 /* Swap the r_offset field in and out.  */
 246 #define SWAP_IN_RELOC_OFFSET  bfd_h_get_32
 247 #define SWAP_OUT_RELOC_OFFSET bfd_h_put_32
 248
 249 /* Swap out extra information in the reloc structure.  */
 250 #define SWAP_OUT_RELOC_EXTRA(abfd, src, dst)    \
 251   do                                            \
 252     {                                           \
 253       dst->r_stuff[0] = 'S';                    \
 254       dst->r_stuff[1] = 'C';                    \
 255     }                                           \
 256   while (0)
 257
 258 /* Get the value of a symbol, when performing a relocation.  */
 259
 260 static long
 261 get_symbol_value (symbol)
 262      asymbol *symbol;
 263 {
 264   bfd_vma relocation;
 265
 266   if (bfd_is_com_section (symbol->section))
 267     relocation = 0;
 268   else
 269     relocation = (symbol->value +
 270                   symbol->section->output_section->vma +
 271                   symbol->section->output_offset);
 272
 273   return relocation;
 274 }
 275
 276 /* This macro is used in coffcode.h to get the howto corresponding to
 277    an internal reloc.  */
 278
 279 #define RTYPE2HOWTO(relent, internal)           \
 280   ((relent)->howto =                            \
 281    ((internal)->r_type < SH_COFF_HOWTO_COUNT    \
 282     ? &sh_coff_howtos[(internal)->r_type]       \
 283     : (reloc_howto_type *) NULL))
 284
 285 /* This is the same as the macro in coffcode.h, except that it copies
 286    r_offset into reloc_entry->addend for some relocs.  */
 287 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
 288   {                                                             \
 289     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
 290     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
 291       coffsym = (obj_symbols (abfd)                             \
 292                  + (cache_ptr->sym_ptr_ptr - symbols));         \
 293     else if (ptr)                                               \
 294       coffsym = coff_symbol_from (abfd, ptr);                   \
 295     if (coffsym != (coff_symbol_type *) NULL                    \
 296         && coffsym->native->u.syment.n_scnum == 0)              \
 297       cache_ptr->addend = 0;                                    \
 298     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
 299              && ptr->section != (asection *) NULL)              \
 300       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
 301     else                                                        \
 302       cache_ptr->addend = 0;                                    \
 303     if ((reloc).r_type == R_SH_SWITCH16                         \
 304         || (reloc).r_type == R_SH_SWITCH32                      \
 305         || (reloc).r_type == R_SH_USES                          \
 306         || (reloc).r_type == R_SH_COUNT                         \
 307         || (reloc).r_type == R_SH_ALIGN)                        \
 308       cache_ptr->addend = (reloc).r_offset;                     \
 309   }
 310
 311 /* This is the howto function for the SH relocations.  */
 312
 313 static bfd_reloc_status_type
 314 sh_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
 315           error_message)
 316      bfd *abfd;
 317      arelent *reloc_entry;
 318      asymbol *symbol_in;
 319      PTR data;
 320      asection *input_section;
 321      bfd *output_bfd;
 322      char **error_message;
 323 {
 324   unsigned long insn;
 325   bfd_vma sym_value;
 326   unsigned short r_type;
 327   bfd_vma addr = reloc_entry->address;
 328   bfd_byte *hit_data = addr + (bfd_byte *) data;
 329
 330   r_type = reloc_entry->howto->type;
 331
 332   if (output_bfd != NULL)
 333     {
 334       /* Partial linking--do nothing.  */
 335       reloc_entry->address += input_section->output_offset;
 336       return bfd_reloc_ok;
 337     }
 338
 339   /* Almost all relocs have to do with relaxing.  If any work must be
 340      done for them, it has been done in sh_relax_section.  */
 341   if (r_type != R_SH_IMM32
 342       && (r_type != R_SH_PCDISP
 343           || (symbol_in->flags & BSF_LOCAL) != 0))
 344     return bfd_reloc_ok;
 345
 346   if (symbol_in != NULL
 347       && bfd_is_und_section (symbol_in->section))
 348     return bfd_reloc_undefined;
 349
 350   sym_value = get_symbol_value (symbol_in);
 351
 352   switch (r_type)
 353     {
 354     case R_SH_IMM32:
 355       insn = bfd_get_32 (abfd, hit_data);
 356       insn += sym_value + reloc_entry->addend;
 357       bfd_put_32 (abfd, insn, hit_data);
 358       break;
 359     case R_SH_PCDISP:
 360       insn = bfd_get_16 (abfd, hit_data);
 361       sym_value += reloc_entry->addend;
 362       sym_value -= (input_section->output_section->vma
 363                     + input_section->output_offset
 364                     + addr
 365                     + 4);
 366       sym_value += (insn & 0xfff) << 1;
 367       if (insn & 0x800)
 368         sym_value -= 0x1000;
 369       insn = (insn & 0xf000) | (sym_value & 0xfff);
 370       bfd_put_16 (abfd, insn, hit_data);
 371       if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
 372         return bfd_reloc_overflow;
 373       break;
 374     default:
 375       abort ();
 376       break;
 377     }
 378
 379   return bfd_reloc_ok;
 380 }
 381
 382 /* We can do relaxing.  */
 383 #define coff_bfd_relax_section sh_relax_section
 384
 385 /* We use the special COFF backend linker.  */
 386 #define coff_relocate_section sh_relocate_section
 387
 388 /* When relaxing, we need to use special code to get the relocated
 389    section contents.  */
 390 #define coff_bfd_get_relocated_section_contents \
 391   sh_coff_get_relocated_section_contents
 392
 393 #include "coffcode.h"
 394
 395 /* This function handles relaxing on the SH.
 396
 397    Function calls on the SH look like this:
 398
 399        movl  L1,r0
 400        ...
 401        jsr   @r0
 402        ...
 403      L1:
 404        .long function
 405
 406    The compiler and assembler will cooperate to create R_SH_USES
 407    relocs on the jsr instructions.  The r_offset field of the
 408    R_SH_USES reloc is the PC relative offset to the instruction which
 409    loads the register (the r_offset field is computed as though it
 410    were a jump instruction, so the offset value is actually from four
 411    bytes past the instruction).  The linker can use this reloc to
 412    determine just which function is being called, and thus decide
 413    whether it is possible to replace the jsr with a bsr.
 414
 415    If multiple function calls are all based on a single register load
 416    (i.e., the same function is called multiple times), the compiler
 417    guarantees that each function call will have an R_SH_USES reloc.
 418    Therefore, if the linker is able to convert each R_SH_USES reloc
 419    which refers to that address, it can safely eliminate the register
 420    load.
 421
 422    When the assembler creates an R_SH_USES reloc, it examines it to
 423    determine which address is being loaded (L1 in the above example).
 424    It then counts the number of references to that address, and
 425    creates an R_SH_COUNT reloc at that address.  The r_offset field of
 426    the R_SH_COUNT reloc will be the number of references.  If the
 427    linker is able to eliminate a register load, it can use the
 428    R_SH_COUNT reloc to see whether it can also eliminate the function
 429    address.  */
 430
 431 static boolean
 432 sh_relax_section (abfd, sec, link_info, again)
 433      bfd *abfd;
 434      asection *sec;
 435      struct bfd_link_info *link_info;
 436      boolean *again;
 437 {
 438   struct internal_reloc *internal_relocs;
 439   struct internal_reloc *free_relocs = NULL;
 440   struct internal_reloc *irel, *irelend;
 441   bfd_byte *contents = NULL;
 442   bfd_byte *free_contents = NULL;
 443
 444   *again = false;
 445
 446   if (link_info->relocateable
 447       || (sec->flags & SEC_RELOC) == 0
 448       || sec->reloc_count == 0)
 449     return true;
 450
 451   /* If this is the first time we have been called for this section,
 452      initialize the cooked size.  */
 453   if (sec->_cooked_size == 0)
 454     sec->_cooked_size = sec->_raw_size;
 455
 456   internal_relocs = (_bfd_coff_read_internal_relocs
 457                      (abfd, sec, link_info->keep_memory,
 458                       (bfd_byte *) NULL, false,
 459                       (struct internal_reloc *) NULL));
 460   if (internal_relocs == NULL)
 461     goto error_return;
 462   if (! link_info->keep_memory)
 463     free_relocs = internal_relocs;
 464
 465   irelend = internal_relocs + sec->reloc_count;
 466   for (irel = internal_relocs; irel < irelend; irel++)
 467     {
 468       bfd_vma laddr, paddr, symval;
 469       unsigned short insn;
 470       struct internal_reloc *irelfn, *irelscan, *irelcount;
 471       struct internal_syment sym;
 472       bfd_signed_vma foff;
 473
 474       if (irel->r_type != R_SH_USES)
 475         continue;
 476
 477       /* Get the section contents.  */
 478       if (contents == NULL)
 479         {
 480           if (coff_section_data (abfd, sec) != NULL
 481               && coff_section_data (abfd, sec)->contents != NULL)
 482             contents = coff_section_data (abfd, sec)->contents;
 483           else
 484             {
 485               contents = (bfd_byte *) malloc (sec->_raw_size);
 486               if (contents == NULL)
 487                 {
 488                   bfd_set_error (bfd_error_no_memory);
 489                   goto error_return;
 490                 }
 491               free_contents = contents;
 492
 493               if (! bfd_get_section_contents (abfd, sec, contents,
 494                                               (file_ptr) 0, sec->_raw_size))
 495                 goto error_return;
 496             }
 497         }
 498
 499       /* The r_offset field of the R_SH_USES reloc will point us to
 500          the register load.  The 4 is because the r_offset field is
 501          computed as though it were a jump offset, which are based
 502          from 4 bytes after the jump instruction.  */
 503       laddr = irel->r_vaddr - sec->vma + 4 + irel->r_offset;
 504       if (laddr >= sec->_raw_size)
 505         {
 506           (*_bfd_error_handler) ("%s: 0x%lx: warning: bad R_SH_USES offset",
 507                                  bfd_get_filename (abfd),
 508                                  (unsigned long) irel->r_vaddr);
 509           continue;
 510         }
 511       insn = bfd_get_16 (abfd, contents + laddr);
 512
 513       /* If the instruction is not mov.l NN,rN, we don't know what to
 514          do.  */
 515       if ((insn & 0xf000) != 0xd000)
 516         {
 517           ((*_bfd_error_handler)
 518            ("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x",
 519             bfd_get_filename (abfd), (unsigned long) irel->r_vaddr, insn));
 520           continue;
 521         }
 522
 523       /* Get the address from which the register is being loaded.  The
 524          displacement in the mov.l instruction is quadrupled.  It is a
 525          displacement from four bytes after the movl instruction, but,
 526          before adding in the PC address, two least significant bits
 527          of the PC are cleared.  We assume that the section is aligned
 528          on a four byte boundary.  */
 529       paddr = insn & 0xff;
 530       paddr *= 4;
 531       paddr += (laddr + 4) &~ 3;
 532       if (paddr >= sec->_raw_size)
 533         {
 534           ((*_bfd_error_handler)
 535            ("%s: 0x%lx: warning: bad R_SH_USES load offset",
 536             bfd_get_filename (abfd), (unsigned long) irel->r_vaddr));
 537           continue;
 538         }
 539
 540       /* Get the reloc for the address from which the register is
 541          being loaded.  This reloc will tell us which function is
 542          actually being called.  */
 543       paddr += sec->vma;
 544       for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
 545         if (irelfn->r_vaddr == paddr
 546             && irelfn->r_type == R_SH_IMM32)
 547           break;
 548       if (irelfn >= irelend)
 549         {
 550           ((*_bfd_error_handler)
 551            ("%s: 0x%lx: warning: could not find expected reloc",
 552             bfd_get_filename (abfd), (unsigned long) paddr));
 553           continue;
 554         }
 555
 556       /* Get the value of the symbol referred to by the reloc.  */
 557       if (! _bfd_coff_get_external_symbols (abfd))
 558         goto error_return;
 559       bfd_coff_swap_sym_in (abfd,
 560                             ((bfd_byte *) obj_coff_external_syms (abfd)
 561                              + (irelfn->r_symndx
 562                                 * bfd_coff_symesz (abfd))),
 563                             &sym);
 564       if (sym.n_scnum != 0 && sym.n_scnum != sec->target_index)
 565         {
 566           ((*_bfd_error_handler)
 567            ("%s: 0x%lx: warning: symbol in unexpected section",
 568             bfd_get_filename (abfd), (unsigned long) paddr));
 569           continue;
 570         }
 571
 572       if (sym.n_sclass != C_EXT)
 573         {
 574           symval = (sym.n_value
 575                     - sec->vma
 576                     + sec->output_section->vma
 577                     + sec->output_offset);
 578         }
 579       else
 580         {
 581           struct coff_link_hash_entry *h;
 582
 583           h = obj_coff_sym_hashes (abfd)[irelfn->r_symndx];
 584           BFD_ASSERT (h != NULL);
 585           if (h->root.type != bfd_link_hash_defined
 586               && h->root.type != bfd_link_hash_defweak)
 587             {
 588               /* This appears to be a reference to an undefined
 589                  symbol.  Just ignore it--it will be caught by the
 590                  regular reloc processing.  */
 591               continue;
 592             }
 593
 594           symval = (h->root.u.def.value
 595                     + h->root.u.def.section->output_section->vma
 596                     + h->root.u.def.section->output_offset);
 597         }
 598
 599       symval += bfd_get_32 (abfd, contents + paddr - sec->vma);
 600
 601       /* See if this function call can be shortened.  */
 602       foff = (symval
 603               - (irel->r_vaddr
 604                  - sec->vma
 605                  + sec->output_section->vma
 606                  + sec->output_offset
 607                  + 4));
 608       if (foff < -0x1000 || foff >= 0x1000)
 609         {
 610           /* After all that work, we can't shorten this function call.  */
 611           continue;
 612         }
 613
 614       /* Shorten the function call.  */
 615
 616       /* For simplicity of coding, we are going to modify the section
 617          contents, the section relocs, and the BFD symbol table.  We
 618          must tell the rest of the code not to free up this
 619          information.  It would be possible to instead create a table
 620          of changes which have to be made, as is done in coff-mips.c;
 621          that would be more work, but would require less memory when
 622          the linker is run.  */
 623
 624       if (coff_section_data (abfd, sec) == NULL)
 625         {
 626           sec->used_by_bfd =
 627             ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
 628           if (sec->used_by_bfd == NULL)
 629             goto error_return;
 630         }
 631
 632       coff_section_data (abfd, sec)->relocs = internal_relocs;
 633       coff_section_data (abfd, sec)->keep_relocs = true;
 634       free_relocs = NULL;
 635
 636       coff_section_data (abfd, sec)->contents = contents;
 637       coff_section_data (abfd, sec)->keep_contents = true;
 638       free_contents = NULL;
 639
 640       obj_coff_keep_syms (abfd) = true;
 641
 642       /* Replace the jsr with a bsr.  */
 643
 644       /* Change the R_SH_USES reloc into an R_SH_PCDISP reloc, and
 645          replace the jsr with a bsr.  */
 646       irel->r_type = R_SH_PCDISP;
 647       irel->r_symndx = irelfn->r_symndx;
 648       if (sym.n_sclass != C_EXT)
 649         {
 650           /* If this needs to be changed because of future relaxing,
 651              it will be handled here like other internal PCDISP
 652              relocs.  */
 653           bfd_put_16 (abfd,
 654                       0xb000 | ((foff >> 1) & 0xfff),
 655                       contents + irel->r_vaddr - sec->vma);
 656         }
 657       else
 658         {
 659           /* We can't fully resolve this yet, because the external
 660              symbol value may be changed by future relaxing.  We let
 661              the final link phase handle it.  */
 662           bfd_put_16 (abfd, 0xb000, contents + irel->r_vaddr - sec->vma);
 663         }
 664
 665       /* See if there is another R_SH_USES reloc referring to the same
 666          register load.  */
 667       for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
 668         if (irelscan->r_type == R_SH_USES
 669             && laddr == irelscan->r_vaddr - sec->vma + 4 + irelscan->r_offset)
 670           break;
 671       if (irelscan < irelend)
 672         {
 673           /* Some other function call depends upon this register load,
 674              and we have not yet converted that function call.
 675              Indeed, we may never be able to convert it.  There is
 676              nothing else we can do at this point.  */
 677           continue;
 678         }
 679
 680       /* Look for a R_SH_COUNT reloc on the location where the
 681          function address is stored.  Do this before deleting any
 682          bytes, to avoid confusion about the address.  */
 683       for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
 684         if (irelcount->r_vaddr == paddr
 685             && irelcount->r_type == R_SH_COUNT)
 686           break;
 687
 688       /* Delete the register load.  */
 689       if (! sh_relax_delete_bytes (abfd, sec, laddr, 2))
 690         goto error_return;
 691
 692       /* That will change things, so, just in case it permits some
 693          other function call to come within range, we should relax
 694          again.  Note that this is not required, and it may be slow.  */
 695       *again = true;
 696
 697       /* Now check whether we got a COUNT reloc.  */
 698       if (irelcount >= irelend)
 699         {
 700           ((*_bfd_error_handler)
 701            ("%s: 0x%lx: warning: could not find expected COUNT reloc",
 702             bfd_get_filename (abfd), (unsigned long) paddr));
 703           continue;
 704         }
 705
 706       /* The number of uses is stored in the r_offset field.  We've
 707          just deleted one.  */
 708       if (irelcount->r_offset == 0)
 709         {
 710           ((*_bfd_error_handler) ("%s: 0x%lx: warning: bad count",
 711                                   bfd_get_filename (abfd),
 712                                   (unsigned long) paddr));
 713           continue;
 714         }
 715
 716       --irelcount->r_offset;
 717
 718       /* If there are no more uses, we can delete the address.  Reload
 719          the address from irelfn, in case it was changed by the
 720          previous call to sh_relax_delete_bytes.  */
 721       if (irelcount->r_offset == 0)
 722         {
 723           if (! sh_relax_delete_bytes (abfd, sec,
 724                                        irelfn->r_vaddr - sec->vma, 4))
 725             goto error_return;
 726         }
 727
 728       /* We've done all we can with that function call.  */
 729     }
 730
 731   if (free_relocs != NULL)
 732     {
 733       free (free_relocs);
 734       free_relocs = NULL;
 735     }
 736
 737   if (free_contents != NULL)
 738     {
 739       if (! link_info->keep_memory)
 740         free (free_contents);
 741       else
 742         {
 743           /* Cache the section contents for coff_link_input_bfd.  */
 744           if (coff_section_data (abfd, sec) == NULL)
 745             {
 746               sec->used_by_bfd =
 747                 ((PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
 748               if (sec->used_by_bfd == NULL)
 749                 goto error_return;
 750               coff_section_data (abfd, sec)->relocs = NULL;
 751             }
 752           coff_section_data (abfd, sec)->contents = contents;
 753         }
 754     }
 755
 756   return true;
 757
 758  error_return:
 759   if (free_relocs != NULL)
 760     free (free_relocs);
 761   if (free_contents != NULL)
 762     free (free_contents);
 763   return false;
 764 }
 765
 766 /* Delete some bytes from a section while relaxing.  */
 767
 768 static boolean
 769 sh_relax_delete_bytes (abfd, sec, addr, count)
 770      bfd *abfd;
 771      asection *sec;
 772      bfd_vma addr;
 773      int count;
 774 {
 775   bfd_byte *contents;
 776   struct internal_reloc *irel, *irelend;
 777   struct internal_reloc *irelalign;
 778   bfd_vma toaddr;
 779   bfd_byte *esym, *esymend;
 780   bfd_size_type symesz;
 781   struct coff_link_hash_entry **sym_hash;
 782   asection *o;
 783
 784   contents = coff_section_data (abfd, sec)->contents;
 785
 786   /* The deletion must stop at the next ALIGN reloc for an aligment
 787      power larger than the number of bytes we are deleting.  */
 788
 789   irelalign = NULL;
 790   toaddr = sec->_cooked_size;
 791
 792   irel = coff_section_data (abfd, sec)->relocs;
 793   irelend = irel + sec->reloc_count;
 794   for (; irel < irelend; irel++)
 795     {
 796       if (irel->r_type == R_SH_ALIGN
 797           && irel->r_vaddr - sec->vma > addr
 798           && count < (1 << irel->r_offset))
 799         {
 800           irelalign = irel;
 801           toaddr = irel->r_vaddr - sec->vma;
 802           break;
 803         }
 804     }
 805
 806   /* Actually delete the bytes.  */
 807   memmove (contents + addr, contents + addr + count, toaddr - addr - count);
 808   if (irelalign == NULL)
 809     sec->_cooked_size -= count;
 810   else
 811     memset (contents + toaddr - count, 0, count);
 812
 813   /* Adjust all the relocs.  */
 814   for (irel = coff_section_data (abfd, sec)->relocs; irel < irelend; irel++)
 815     {
 816       bfd_vma nraddr, start, stop;
 817       int insn = 0;
 818       struct internal_syment sym;
 819       int off, adjust, oinsn;
 820       bfd_signed_vma voff;
 821       boolean overflow;
 822
 823       /* Get the new reloc address.  */
 824       nraddr = irel->r_vaddr - sec->vma;
 825       if ((irel->r_vaddr - sec->vma > addr
 826            && irel->r_vaddr - sec->vma < toaddr)
 827           || (irel->r_type == R_SH_ALIGN
 828               && irel->r_vaddr - sec->vma == toaddr))
 829         nraddr -= count;
 830
 831       /* See if this reloc was for the bytes we have deleted, in which
 832          case we no longer care about it.  */
 833       if (irel->r_vaddr - sec->vma >= addr
 834           && irel->r_vaddr - sec->vma < addr + count
 835           && irel->r_type != R_SH_ALIGN)
 836         irel->r_type = R_SH_UNUSED;
 837
 838       /* If this is a PC relative reloc, see if the range it covers
 839          includes the bytes we have deleted.  */
 840       switch (irel->r_type)
 841         {
 842         default:
 843           break;
 844
 845         case R_SH_PCDISP8BY2:
 846         case R_SH_PCDISP:
 847         case R_SH_PCRELIMM8BY2:
 848         case R_SH_PCRELIMM8BY4:
 849           start = irel->r_vaddr - sec->vma;
 850           insn = bfd_get_16 (abfd, contents + nraddr);
 851           break;
 852         }
 853
 854       switch (irel->r_type)
 855         {
 856         default:
 857           start = stop = addr;
 858           break;
 859
 860         case R_SH_IMM32:
 861           /* If this reloc is against a symbol defined in this
 862              section, and the symbol will not be adjusted below, we
 863              must check the addend to see it will put the value in
 864              range to be adjusted, and hence must be changed.  */
 865           bfd_coff_swap_sym_in (abfd,
 866                                 ((bfd_byte *) obj_coff_external_syms (abfd)
 867                                  + (irel->r_symndx
 868                                     * bfd_coff_symesz (abfd))),
 869                                 &sym);
 870           if (sym.n_sclass != C_EXT
 871               && sym.n_scnum == sec->target_index
 872               && ((bfd_vma) sym.n_value <= addr
 873                   || (bfd_vma) sym.n_value >= toaddr))
 874             {
 875               bfd_vma val;
 876
 877               val = bfd_get_32 (abfd, contents + nraddr);
 878               val += sym.n_value;
 879               if (val >= addr && val < toaddr)
 880                 bfd_put_32 (abfd, val - count, contents + nraddr);
 881             }
 882           start = stop = addr;
 883           break;
 884
 885         case R_SH_PCDISP8BY2:
 886           off = insn & 0xff;
 887           if (off & 0x80)
 888             off -= 0x100;
 889           stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
 890           break;
 891
 892         case R_SH_PCDISP:
 893           bfd_coff_swap_sym_in (abfd,
 894                                 ((bfd_byte *) obj_coff_external_syms (abfd)
 895                                  + (irel->r_symndx
 896                                     * bfd_coff_symesz (abfd))),
 897                                 &sym);
 898           if (sym.n_sclass == C_EXT)
 899             start = stop = addr;
 900           else
 901             {
 902               off = insn & 0xfff;
 903               if (off & 0x800)
 904                 off -= 0x1000;
 905               stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
 906             }
 907           break;
 908
 909         case R_SH_PCRELIMM8BY2:
 910           off = insn & 0xff;
 911           stop = start + 4 + off * 2;
 912           break;
 913
 914         case R_SH_PCRELIMM8BY4:
 915           off = insn & 0xff;
 916           stop = (start &~ (bfd_vma) 3) + 4 + off * 4;
 917           break;
 918
 919         case R_SH_SWITCH16:
 920         case R_SH_SWITCH32:
 921           /* These relocs types represent
 922                .word L2-L1
 923              The r_offset field holds the difference between the reloc
 924              address and L1.  That is the start of the reloc, and
 925              adding in the contents gives us the top.  We must adjust
 926              both the r_offset field and the section contents.  */
 927
 928           start = irel->r_vaddr - sec->vma;
 929           stop = (bfd_vma) ((bfd_signed_vma) start - (long) irel->r_offset);
 930
 931           if (start > addr
 932               && start < toaddr
 933               && (stop <= addr || stop >= toaddr))
 934             irel->r_offset += count;
 935           else if (stop > addr
 936                    && stop < toaddr
 937                    && (start <= addr || start >= toaddr))
 938             irel->r_offset -= count;
 939
 940           start = stop;
 941
 942           if (irel->r_type == R_SH_SWITCH16)
 943             voff = bfd_get_signed_16 (abfd, contents + nraddr);
 944           else
 945             voff = bfd_get_signed_32 (abfd, contents + nraddr);
 946           stop = (bfd_vma) ((bfd_signed_vma) start + voff);
 947
 948           break;
 949
 950         case R_SH_USES:
 951           start = irel->r_vaddr - sec->vma;
 952           stop = (bfd_vma) ((bfd_signed_vma) start + (long) irel->r_offset);
 953           break;
 954         }
 955
 956       if (start > addr
 957           && start < toaddr
 958           && (stop <= addr || stop >= toaddr))
 959         adjust = count;
 960       else if (stop > addr
 961                && stop < toaddr
 962                && (start <= addr || start >= toaddr))
 963         adjust = - count;
 964       else
 965         adjust = 0;
 966
 967       if (adjust != 0)
 968         {
 969           oinsn = insn;
 970           overflow = false;
 971           switch (irel->r_type)
 972             {
 973             default:
 974               abort ();
 975               break;
 976
 977             case R_SH_PCDISP8BY2:
 978             case R_SH_PCRELIMM8BY2:
 979               insn += adjust / 2;
 980               if ((oinsn & 0xff00) != (insn & 0xff00))
 981                 overflow = true;
 982               bfd_put_16 (abfd, insn, contents + nraddr);
 983               break;
 984
 985             case R_SH_PCDISP:
 986               insn += adjust / 2;
 987               if ((oinsn & 0xf000) != (insn & 0xf000))
 988                 overflow = true;
 989               bfd_put_16 (abfd, insn, contents + nraddr);
 990               break;
 991
 992             case R_SH_PCRELIMM8BY4:
 993               BFD_ASSERT (adjust == count || count >= 4);
 994               if (count >= 4)
 995                 insn += adjust / 4;
 996               else
 997                 {
 998                   if ((irel->r_vaddr & 3) == 0)
 999                     ++insn;
1000                 }
1001               if ((oinsn & 0xff00) != (insn & 0xff00))
1002                 overflow = true;
1003               bfd_put_16 (abfd, insn, contents + nraddr);
1004               break;
1005
1006             case R_SH_SWITCH16:
1007               voff += adjust;
1008               if (voff < - 0x8000 || voff >= 0x8000)
1009                 overflow = true;
1010               bfd_put_signed_16 (abfd, voff, contents + nraddr);
1011               break;
1012
1013             case R_SH_SWITCH32:
1014               voff += adjust;
1015               bfd_put_signed_32 (abfd, voff, contents + nraddr);
1016               break;
1017
1018             case R_SH_USES:
1019               irel->r_offset += adjust;
1020               break;
1021             }
1022
1023           if (overflow)
1024             {
1025               ((*_bfd_error_handler)
1026                ("%s: 0x%lx: fatal: reloc overflow while relaxing",
1027                 bfd_get_filename (abfd), (unsigned long) irel->r_vaddr));
1028               bfd_set_error (bfd_error_bad_value);
1029               return false;
1030             }
1031         }
1032
1033       irel->r_vaddr = nraddr + sec->vma;
1034     }
1035
1036   /* Look through all the other sections.  If there contain any IMM32
1037      relocs against internal symbols which we are not going to adjust
1038      below, we may need to adjust the addends.  */
1039   for (o = abfd->sections; o != NULL; o = o->next)
1040     {
1041       struct internal_reloc *internal_relocs;
1042       struct internal_reloc *irelscan, *irelscanend;
1043       bfd_byte *ocontents;
1044
1045       if (o == sec
1046           || (o->flags & SEC_RELOC) == 0
1047           || o->reloc_count == 0)
1048         continue;
1049
1050       /* We always cache the relocs.  Perhaps, if info->keep_memory is
1051          false, we should free them, if we are permitted to, when we
1052          leave sh_coff_relax_section.  */
1053       internal_relocs = (_bfd_coff_read_internal_relocs
1054                          (abfd, o, true, (bfd_byte *) NULL, false,
1055                           (struct internal_reloc *) NULL));
1056       if (internal_relocs == NULL)
1057         return false;
1058
1059       ocontents = NULL;
1060       irelscanend = internal_relocs + o->reloc_count;
1061       for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1062         {
1063           struct internal_syment sym;
1064
1065           if (irelscan->r_type != R_SH_IMM32)
1066             continue;
1067
1068           bfd_coff_swap_sym_in (abfd,
1069                                 ((bfd_byte *) obj_coff_external_syms (abfd)
1070                                  + (irelscan->r_symndx
1071                                     * bfd_coff_symesz (abfd))),
1072                                 &sym);
1073           if (sym.n_sclass != C_EXT
1074               && sym.n_scnum == sec->target_index
1075               && ((bfd_vma) sym.n_value <= addr
1076                   || (bfd_vma) sym.n_value >= toaddr))
1077             {
1078               bfd_vma val;
1079
1080               if (ocontents == NULL)
1081                 {
1082                   if (coff_section_data (abfd, o)->contents != NULL)
1083                     ocontents = coff_section_data (abfd, o)->contents;
1084                   else
1085                     {
1086                       /* We always cache the section contents.
1087                          Perhaps, if info->keep_memory is false, we
1088                          should free them, if we are permitted to,
1089                          when we leave sh_coff_relax_section.  */
1090                       ocontents = (bfd_byte *) malloc (o->_raw_size);
1091                       if (ocontents == NULL)
1092                         {
1093                           bfd_set_error (bfd_error_no_memory);
1094                           return false;
1095                         }
1096                       if (! bfd_get_section_contents (abfd, o, ocontents,
1097                                                       (file_ptr) 0,
1098                                                       o->_raw_size))
1099                         return false;
1100                       coff_section_data (abfd, o)->contents = ocontents;
1101                     }
1102                 }
1103
1104               val = bfd_get_32 (abfd, ocontents + irelscan->r_vaddr - o->vma);
1105               val += sym.n_value;
1106               if (val >= addr && val < toaddr)
1107                 bfd_put_32 (abfd, val - count,
1108                             ocontents + irelscan->r_vaddr - o->vma);
1109
1110               coff_section_data (abfd, o)->keep_contents = true;
1111             }
1112         }
1113     }
1114
1115   /* Adjusting the internal symbols will not work if something has
1116      already retrieved the generic symbols.  It would be possible to
1117      make this work by adjusting the generic symbols at the same time.
1118      However, this case should not arise in normal usage.  */
1119   if (obj_symbols (abfd) != NULL
1120       || obj_raw_syments (abfd) != NULL)
1121     {
1122       ((*_bfd_error_handler)
1123        ("%s: fatal: generic symbols retrieved before relaxing",
1124         bfd_get_filename (abfd)));
1125       bfd_set_error (bfd_error_invalid_operation);
1126       return false;
1127     }
1128
1129   /* Adjust all the symbols.  */
1130   sym_hash = obj_coff_sym_hashes (abfd);
1131   symesz = bfd_coff_symesz (abfd);
1132   esym = (bfd_byte *) obj_coff_external_syms (abfd);
1133   esymend = esym + obj_raw_syment_count (abfd) * symesz;
1134   while (esym < esymend)
1135     {
1136       struct internal_syment isym;
1137
1138       bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
1139
1140       if (isym.n_scnum == sec->target_index
1141           && (bfd_vma) isym.n_value > addr
1142           && (bfd_vma) isym.n_value < toaddr)
1143         {
1144           isym.n_value -= count;
1145
1146           bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym);
1147
1148           if (*sym_hash != NULL)
1149             {
1150               BFD_ASSERT ((*sym_hash)->root.type == bfd_link_hash_defined
1151                           || (*sym_hash)->root.type == bfd_link_hash_defweak);
1152               BFD_ASSERT ((*sym_hash)->root.u.def.value >= addr
1153                           && (*sym_hash)->root.u.def.value < toaddr);
1154               (*sym_hash)->root.u.def.value -= count;
1155             }
1156         }
1157
1158       esym += (isym.n_numaux + 1) * symesz;
1159       sym_hash += isym.n_numaux + 1;
1160     }
1161
1162   /* See if we can move the ALIGN reloc forward.  We have adjusted
1163      r_vaddr for it already.  */
1164   if (irelalign != NULL)
1165     {
1166       bfd_vma alignaddr;
1167
1168       alignaddr = BFD_ALIGN (irelalign->r_vaddr - sec->vma,
1169                              1 << irelalign->r_offset);
1170       if (alignaddr != toaddr)
1171         {
1172           /* Tail recursion.  */
1173           return sh_relax_delete_bytes (abfd, sec,
1174                                         irelalign->r_vaddr - sec->vma,
1175                                         1 << irelalign->r_offset);
1176         }
1177     }
1178
1179   return true;
1180 }
1181
1182 /* This is a modification of _bfd_coff_generic_relocate_section, which
1183    will handle SH relaxing.  */
1184
1185 static boolean
1186 sh_relocate_section (output_bfd, info, input_bfd, input_section, contents,
1187                      relocs, syms, sections)
1188      bfd *output_bfd;
1189      struct bfd_link_info *info;
1190      bfd *input_bfd;
1191      asection *input_section;
1192      bfd_byte *contents;
1193      struct internal_reloc *relocs;
1194      struct internal_syment *syms;
1195      asection **sections;
1196 {
1197   struct internal_reloc *rel;
1198   struct internal_reloc *relend;
1199
1200   rel = relocs;
1201   relend = rel + input_section->reloc_count;
1202   for (; rel < relend; rel++)
1203     {
1204       long symndx;
1205       struct coff_link_hash_entry *h;
1206       struct internal_syment *sym;
1207       bfd_vma addend;
1208       bfd_vma val;
1209       reloc_howto_type *howto;
1210       bfd_reloc_status_type rstat;
1211
1212       /* Almost all relocs have to do with relaxing.  If any work must
1213          be done for them, it has been done in sh_relax_section.  */
1214       if (rel->r_type != R_SH_IMM32
1215           && rel->r_type != R_SH_PCDISP)
1216         continue;
1217
1218       symndx = rel->r_symndx;
1219
1220       if (symndx == -1)
1221         {
1222           h = NULL;
1223           sym = NULL;
1224         }
1225       else
1226         {
1227           h = obj_coff_sym_hashes (input_bfd)[symndx];
1228           sym = syms + symndx;
1229         }
1230
1231       if (sym != NULL && sym->n_scnum != 0)
1232         addend = - sym->n_value;
1233       else
1234         addend = 0;
1235
1236       if (rel->r_type == R_SH_PCDISP)
1237         addend -= 4;
1238
1239       if (rel->r_type >= SH_COFF_HOWTO_COUNT)
1240         howto = NULL;
1241       else
1242         howto = &sh_coff_howtos[rel->r_type];
1243
1244       if (howto == NULL)
1245         {
1246           bfd_set_error (bfd_error_bad_value);
1247           return false;
1248         }
1249
1250       val = 0;
1251
1252       if (h == NULL)
1253         {
1254           asection *sec;
1255
1256           /* There is nothing to do for an internal PCDISP reloc.  */
1257           if (rel->r_type == R_SH_PCDISP)
1258             continue;
1259
1260           if (symndx == -1)
1261             {
1262               sec = bfd_abs_section_ptr;
1263               val = 0;
1264             }
1265           else
1266             {
1267               sec = sections[symndx];
1268               val = (sec->output_section->vma
1269                      + sec->output_offset
1270                      + sym->n_value
1271                      - sec->vma);
1272             }
1273         }
1274       else
1275         {
1276           if (h->root.type == bfd_link_hash_defined
1277               || h->root.type == bfd_link_hash_defweak)
1278             {
1279               asection *sec;
1280
1281               sec = h->root.u.def.section;
1282               val = (h->root.u.def.value
1283                      + sec->output_section->vma
1284                      + sec->output_offset);
1285             }
1286           else if (! info->relocateable)
1287             {
1288               if (! ((*info->callbacks->undefined_symbol)
1289                      (info, h->root.root.string, input_bfd, input_section,
1290                       rel->r_vaddr - input_section->vma)))
1291                 return false;
1292             }
1293         }
1294
1295       rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
1296                                         contents,
1297                                         rel->r_vaddr - input_section->vma,
1298                                         val, addend);
1299
1300       switch (rstat)
1301         {
1302         default:
1303           abort ();
1304         case bfd_reloc_ok:
1305           break;
1306         case bfd_reloc_overflow:
1307           {
1308             const char *name;
1309             char buf[SYMNMLEN + 1];
1310
1311             if (symndx == -1)
1312               name = "*ABS*";
1313             else if (h != NULL)
1314               name = h->root.root.string;
1315             else if (sym->_n._n_n._n_zeroes == 0
1316                      && sym->_n._n_n._n_offset != 0)
1317               name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
1318             else
1319               {
1320                 strncpy (buf, sym->_n._n_name, SYMNMLEN);
1321                 buf[SYMNMLEN] = '\0';
1322                 name = buf;
1323               }
1324
1325             if (! ((*info->callbacks->reloc_overflow)
1326                    (info, name, howto->name, (bfd_vma) 0, input_bfd,
1327                     input_section, rel->r_vaddr - input_section->vma)))
1328               return false;
1329           }
1330         }
1331     }
1332
1333   return true;
1334 }
1335
1336 /* This is a version of bfd_generic_get_relocated_section_contents
1337    which uses sh_relocate_section.  */
1338
1339 static bfd_byte *
1340 sh_coff_get_relocated_section_contents (output_bfd, link_info, link_order,
1341                                         data, relocateable, symbols)
1342      bfd *output_bfd;
1343      struct bfd_link_info *link_info;
1344      struct bfd_link_order *link_order;
1345      bfd_byte *data;
1346      boolean relocateable;
1347      asymbol **symbols;
1348 {
1349   asection *input_section = link_order->u.indirect.section;
1350   bfd *input_bfd = input_section->owner;
1351   asection **sections = NULL;
1352   struct internal_reloc *internal_relocs = NULL;
1353   struct internal_syment *internal_syms = NULL;
1354
1355   /* We only need to handle the case of relaxing, or of having a
1356      particular set of section contents, specially.  */
1357   if (relocateable
1358       || coff_section_data (input_bfd, input_section) == NULL
1359       || coff_section_data (input_bfd, input_section)->contents == NULL)
1360     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1361                                                        link_order, data,
1362                                                        relocateable,
1363                                                        symbols);
1364
1365   memcpy (data, coff_section_data (input_bfd, input_section)->contents,
1366           input_section->_raw_size);
1367
1368   if ((input_section->flags & SEC_RELOC) != 0
1369       && input_section->reloc_count > 0)
1370     {
1371       bfd_size_type symesz = bfd_coff_symesz (input_bfd);
1372       bfd_byte *esym, *esymend;
1373       struct internal_syment *isymp;
1374       asection **secpp;
1375
1376       if (! _bfd_coff_get_external_symbols (input_bfd))
1377         goto error_return;
1378
1379       internal_relocs = (_bfd_coff_read_internal_relocs
1380                          (input_bfd, input_section, false, (bfd_byte *) NULL,
1381                           false, (struct internal_reloc *) NULL));
1382       if (internal_relocs == NULL)
1383         goto error_return;
1384
1385       internal_syms = ((struct internal_syment *)
1386                        malloc (obj_raw_syment_count (input_bfd)
1387                                * sizeof (struct internal_syment)));
1388       if (internal_syms == NULL)
1389         {
1390           bfd_set_error (bfd_error_no_memory);
1391           goto error_return;
1392         }
1393
1394       sections = (asection **) malloc (obj_raw_syment_count (input_bfd)
1395                                        * sizeof (asection *));
1396       if (sections == NULL)
1397         {
1398           bfd_set_error (bfd_error_no_memory);
1399           goto error_return;
1400         }
1401
1402       isymp = internal_syms;
1403       secpp = sections;
1404       esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1405       esymend = esym + obj_raw_syment_count (input_bfd) * symesz;
1406       while (esym < esymend)
1407         {
1408           bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
1409
1410           if (isymp->n_scnum != 0)
1411             *secpp = coff_section_from_bfd_index (input_bfd, isymp->n_scnum);
1412           else
1413             {
1414               if (isymp->n_value == 0)
1415                 *secpp = bfd_und_section_ptr;
1416               else
1417                 *secpp = bfd_com_section_ptr;
1418             }
1419
1420           esym += (isymp->n_numaux + 1) * symesz;
1421           secpp += isymp->n_numaux + 1;
1422           isymp += isymp->n_numaux + 1;
1423         }
1424
1425       if (! sh_relocate_section (output_bfd, link_info, input_bfd,
1426                                  input_section, data, internal_relocs,
1427                                  internal_syms, sections))
1428         goto error_return;
1429
1430       free (sections);
1431       sections = NULL;
1432       free (internal_syms);
1433       internal_syms = NULL;
1434       free (internal_relocs);
1435       internal_relocs = NULL;
1436     }
1437
1438   return data;
1439
1440  error_return:
1441   if (internal_relocs != NULL)
1442     free (internal_relocs);
1443   if (internal_syms != NULL)
1444     free (internal_syms);
1445   if (sections != NULL)
1446     free (sections);
1447   return NULL;
1448 }
1449
1450 /* The target vectors.  */
1451
1452 const bfd_target shcoff_vec =
1453 {
1454   "coff-sh",                    /* name */
1455   bfd_target_coff_flavour,
1456   true,                         /* data byte order is big */
1457   true,                         /* header byte order is big */
1458
1459   (HAS_RELOC | EXEC_P |         /* object flags */
1460    HAS_LINENO | HAS_DEBUG |
1461    HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE),
1462
1463   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),
1464   '_',                          /* leading symbol underscore */
1465   '/',                          /* ar_pad_char */
1466   15,                           /* ar_max_namelen */
1467   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1468   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1469   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1470   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1471   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1472   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1473
1474   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1475      bfd_generic_archive_p, _bfd_dummy_target},
1476   {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
1477      bfd_false},
1478   {bfd_false, coff_write_object_contents, /* bfd_write_contents */
1479      _bfd_write_archive_contents, bfd_false},
1480
1481   BFD_JUMP_TABLE_GENERIC (coff),
1482   BFD_JUMP_TABLE_COPY (coff),
1483   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1484   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
1485   BFD_JUMP_TABLE_SYMBOLS (coff),
1486   BFD_JUMP_TABLE_RELOCS (coff),
1487   BFD_JUMP_TABLE_WRITE (coff),
1488   BFD_JUMP_TABLE_LINK (coff),
1489   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1490
1491   COFF_SWAP_TABLE,
1492 };
1493
1494 const bfd_target shlcoff_vec =
1495 {
1496   "coff-shl",                   /* name */
1497   bfd_target_coff_flavour,
1498   false,                        /* data byte order is little */
1499   false,                        /* header byte order is little endian too*/
1500
1501   (HAS_RELOC | EXEC_P |         /* object flags */
1502    HAS_LINENO | HAS_DEBUG |
1503    HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE),
1504
1505   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),
1506   '_',                          /* leading symbol underscore */
1507   '/',                          /* ar_pad_char */
1508   15,                           /* ar_max_namelen */
1509   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1510   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1511   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1512   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1513   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1514   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1515
1516   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1517      bfd_generic_archive_p, _bfd_dummy_target},
1518   {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
1519      bfd_false},
1520   {bfd_false, coff_write_object_contents, /* bfd_write_contents */
1521      _bfd_write_archive_contents, bfd_false},
1522
1523   BFD_JUMP_TABLE_GENERIC (coff),
1524   BFD_JUMP_TABLE_COPY (coff),
1525   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1526   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
1527   BFD_JUMP_TABLE_SYMBOLS (coff),
1528   BFD_JUMP_TABLE_RELOCS (coff),
1529   BFD_JUMP_TABLE_WRITE (coff),
1530   BFD_JUMP_TABLE_LINK (coff),
1531   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1532
1533   COFF_SWAP_TABLE,
1534 };