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