Subversion Repositories openrisc

/* BFD back-end for MIPS Extended-Coff files.

   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

   2000, 2001, 2002, 2003, 2004, 2007, 2008

   Free Software Foundation, Inc.

   Original version by Per Bothner.

   Full support added by Ian Lance Taylor, ian@cygnus.com.

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

#include "sysdep.h"

#include "bfd.h"

#include "bfdlink.h"

#include "libbfd.h"

#include "coff/internal.h"

#include "coff/sym.h"

#include "coff/symconst.h"

#include "coff/ecoff.h"

#include "coff/mips.h"

#include "libcoff.h"

#include "libecoff.h"

/* Prototypes for static functions.  */

static bfd_boolean mips_ecoff_bad_format_hook

  PARAMS ((bfd *abfd, PTR filehdr));

static void mips_ecoff_swap_reloc_in

  PARAMS ((bfd *, PTR, struct internal_reloc *));

static void mips_ecoff_swap_reloc_out

  PARAMS ((bfd *, const struct internal_reloc *, PTR));

static void mips_adjust_reloc_in

  PARAMS ((bfd *, const struct internal_reloc *, arelent *));

static void mips_adjust_reloc_out

  PARAMS ((bfd *, const arelent *, struct internal_reloc *));

static bfd_reloc_status_type mips_generic_reloc

  PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,

           asection *section, bfd *output_bfd, char **error));

static bfd_reloc_status_type mips_refhi_reloc

  PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,

           asection *section, bfd *output_bfd, char **error));

static bfd_reloc_status_type mips_reflo_reloc

  PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,

           asection *section, bfd *output_bfd, char **error));

static bfd_reloc_status_type mips_gprel_reloc

  PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,

           asection *section, bfd *output_bfd, char **error));

static void mips_relocate_hi

  PARAMS ((struct internal_reloc *refhi, struct internal_reloc *reflo,

           bfd *input_bfd, asection *input_section, bfd_byte *contents,

           bfd_vma relocation));

static bfd_boolean mips_relocate_section

  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, PTR));

static reloc_howto_type *mips_bfd_reloc_type_lookup

  PARAMS ((bfd *, bfd_reloc_code_real_type));

/* ECOFF has COFF sections, but the debugging information is stored in

   a completely different format.  ECOFF targets use some of the

   swapping routines from coffswap.h, and some of the generic COFF

   routines in coffgen.c, but, unlike the real COFF targets, do not

   use coffcode.h itself.

   Get the generic COFF swapping routines, except for the reloc,

   symbol, and lineno ones.  Give them ECOFF names.  */

#define MIPSECOFF

#define NO_COFF_RELOCS

#define NO_COFF_SYMBOLS

#define NO_COFF_LINENOS

#define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in

#define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out

#define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in

#define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out

#define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in

#define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out

#include "coffswap.h"

/* Get the ECOFF swapping routines.  */

#define ECOFF_32

#include "ecoffswap.h"

/* How to process the various relocs types.  */

static reloc_howto_type mips_howto_table[] =

{

  /* Reloc type 0 is ignored.  The reloc reading code ensures that

     this is a reference to the .abs section, which will cause

     bfd_perform_relocation to do nothing.  */

  HOWTO (MIPS_R_IGNORE, /* type */

         0,                      /* rightshift */

         0,                      /* size (0 = byte, 1 = short, 2 = long) */

         8,                     /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_dont, /* complain_on_overflow */

         0,                      /* special_function */

         "IGNORE",              /* name */

         FALSE,                 /* partial_inplace */

         0,                      /* src_mask */

         0,                      /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A 16 bit reference to a symbol, normally from a data section.  */

  HOWTO (MIPS_R_REFHALF,        /* type */

         0,                      /* rightshift */

         1,                     /* size (0 = byte, 1 = short, 2 = long) */

         16,                    /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_bitfield, /* complain_on_overflow */

         mips_generic_reloc,    /* special_function */

         "REFHALF",             /* name */

         TRUE,                  /* partial_inplace */

         0xffff,                /* src_mask */

         0xffff,                /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A 32 bit reference to a symbol, normally from a data section.  */

  HOWTO (MIPS_R_REFWORD,        /* type */

         0,                      /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         32,                    /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_bitfield, /* complain_on_overflow */

         mips_generic_reloc,    /* special_function */

         "REFWORD",             /* name */

         TRUE,                  /* partial_inplace */

         0xffffffff,            /* src_mask */

         0xffffffff,            /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A 26 bit absolute jump address.  */

  HOWTO (MIPS_R_JMPADDR,        /* type */

         2,                     /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         26,                    /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_dont, /* complain_on_overflow */

                                /* This needs complex overflow

                                   detection, because the upper four

                                   bits must match the PC.  */

         mips_generic_reloc,    /* special_function */

         "JMPADDR",             /* name */

         TRUE,                  /* partial_inplace */

         0x3ffffff,             /* src_mask */

         0x3ffffff,             /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* The high 16 bits of a symbol value.  Handled by the function

     mips_refhi_reloc.  */

  HOWTO (MIPS_R_REFHI,          /* type */

         16,                    /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         16,                    /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_bitfield, /* complain_on_overflow */

         mips_refhi_reloc,      /* special_function */

         "REFHI",               /* name */

         TRUE,                  /* partial_inplace */

         0xffff,                /* src_mask */

         0xffff,                /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* The low 16 bits of a symbol value.  */

  HOWTO (MIPS_R_REFLO,          /* type */

         0,                      /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         16,                    /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_dont, /* complain_on_overflow */

         mips_reflo_reloc,      /* special_function */

         "REFLO",               /* name */

         TRUE,                  /* partial_inplace */

         0xffff,                /* src_mask */

         0xffff,                /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A reference to an offset from the gp register.  Handled by the

     function mips_gprel_reloc.  */

  HOWTO (MIPS_R_GPREL,          /* type */

         0,                      /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         16,                    /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_signed, /* complain_on_overflow */

         mips_gprel_reloc,      /* special_function */

         "GPREL",               /* name */

         TRUE,                  /* partial_inplace */

         0xffff,                /* src_mask */

         0xffff,                /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A reference to a literal using an offset from the gp register.

     Handled by the function mips_gprel_reloc.  */

  HOWTO (MIPS_R_LITERAL,        /* type */

         0,                      /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         16,                    /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_signed, /* complain_on_overflow */

         mips_gprel_reloc,      /* special_function */

         "LITERAL",             /* name */

         TRUE,                  /* partial_inplace */

         0xffff,                /* src_mask */

         0xffff,                /* dst_mask */

         FALSE),                /* pcrel_offset */

  EMPTY_HOWTO (8),

  EMPTY_HOWTO (9),

  EMPTY_HOWTO (10),

  EMPTY_HOWTO (11),

  /* FIXME: This relocation is used (internally only) to represent branches

     when assembling.  It should never appear in output files, and

     be removed.  (It used to be used for embedded-PIC support.)  */

  HOWTO (MIPS_R_PCREL16,        /* type */

         2,                     /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         16,                    /* bitsize */

         TRUE,                  /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_signed, /* complain_on_overflow */

         mips_generic_reloc,    /* special_function */

         "PCREL16",             /* name */

         TRUE,                  /* partial_inplace */

         0xffff,                /* src_mask */

         0xffff,                /* dst_mask */

         TRUE),                 /* pcrel_offset */

};

#define MIPS_HOWTO_COUNT \

  (sizeof mips_howto_table / sizeof mips_howto_table[0])

/* See whether the magic number matches.  */

static bfd_boolean

mips_ecoff_bad_format_hook (abfd, filehdr)

     bfd *abfd;

     PTR filehdr;

{

  struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;

  switch (internal_f->f_magic)

    {

    case MIPS_MAGIC_1:

      /* I don't know what endianness this implies.  */

      return TRUE;

    case MIPS_MAGIC_BIG:

    case MIPS_MAGIC_BIG2:

    case MIPS_MAGIC_BIG3:

      return bfd_big_endian (abfd);

    case MIPS_MAGIC_LITTLE:

    case MIPS_MAGIC_LITTLE2:

    case MIPS_MAGIC_LITTLE3:

      return bfd_little_endian (abfd);

    default:

      return FALSE;

    }

}

/* Reloc handling.  MIPS ECOFF relocs are packed into 8 bytes in

   external form.  They use a bit which indicates whether the symbol

   is external.  */

/* Swap a reloc in.  */

static void

mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)

     bfd *abfd;

     PTR ext_ptr;

     struct internal_reloc *intern;

{

  const RELOC *ext = (RELOC *) ext_ptr;

  intern->r_vaddr = H_GET_32 (abfd, ext->r_vaddr);

  if (bfd_header_big_endian (abfd))

    {

      intern->r_symndx = (((int) ext->r_bits[0]

                           << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)

                          | ((int) ext->r_bits[1]

                             << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)

                          | ((int) ext->r_bits[2]

                             << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));

      intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)

                        >> RELOC_BITS3_TYPE_SH_BIG);

      intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;

    }

  else

    {

      intern->r_symndx = (((int) ext->r_bits[0]

                           << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)

                          | ((int) ext->r_bits[1]

                             << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)

                          | ((int) ext->r_bits[2]

                             << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));

      intern->r_type = (((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)

                         >> RELOC_BITS3_TYPE_SH_LITTLE)

                        | ((ext->r_bits[3] & RELOC_BITS3_TYPEHI_LITTLE)

                           << RELOC_BITS3_TYPEHI_SH_LITTLE));

      intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;

    }

}

/* Swap a reloc out.  */

static void

mips_ecoff_swap_reloc_out (abfd, intern, dst)

     bfd *abfd;

     const struct internal_reloc *intern;

     PTR dst;

{

  RELOC *ext = (RELOC *) dst;

  long r_symndx;

  BFD_ASSERT (intern->r_extern

              || (intern->r_symndx >= 0 && intern->r_symndx <= 12));

  r_symndx = intern->r_symndx;

  H_PUT_32 (abfd, intern->r_vaddr, ext->r_vaddr);

  if (bfd_header_big_endian (abfd))

    {

      ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;

      ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;

      ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;

      ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)

                         & RELOC_BITS3_TYPE_BIG)

                        | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));

    }

  else

    {

      ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;

      ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;

      ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;

      ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)

                         & RELOC_BITS3_TYPE_LITTLE)

                        | ((intern->r_type >> RELOC_BITS3_TYPEHI_SH_LITTLE

                            & RELOC_BITS3_TYPEHI_LITTLE))

                        | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));

    }

}

/* Finish canonicalizing a reloc.  Part of this is generic to all

   ECOFF targets, and that part is in ecoff.c.  The rest is done in

   this backend routine.  It must fill in the howto field.  */

static void

mips_adjust_reloc_in (abfd, intern, rptr)

     bfd *abfd;

     const struct internal_reloc *intern;

     arelent *rptr;

{

  if (intern->r_type > MIPS_R_PCREL16)

    abort ();

  if (! intern->r_extern

      && (intern->r_type == MIPS_R_GPREL

          || intern->r_type == MIPS_R_LITERAL))

    rptr->addend += ecoff_data (abfd)->gp;

  /* If the type is MIPS_R_IGNORE, make sure this is a reference to

     the absolute section so that the reloc is ignored.  */

  if (intern->r_type == MIPS_R_IGNORE)

    rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;

  rptr->howto = &mips_howto_table[intern->r_type];

}

/* Make any adjustments needed to a reloc before writing it out.  None

   are needed for MIPS.  */

static void

mips_adjust_reloc_out (abfd, rel, intern)

     bfd *abfd ATTRIBUTE_UNUSED;

     const arelent *rel ATTRIBUTE_UNUSED;

     struct internal_reloc *intern ATTRIBUTE_UNUSED;

{

}

/* ECOFF relocs are either against external symbols, or against

   sections.  If we are producing relocatable output, and the reloc

   is against an external symbol, and nothing has given us any

   additional addend, the resulting reloc will also be against the

   same symbol.  In such a case, we don't want to change anything

   about the way the reloc is handled, since it will all be done at

   final link time.  Rather than put special case code into

   bfd_perform_relocation, all the reloc types use this howto

   function.  It just short circuits the reloc if producing

   relocatable output against an external symbol.  */

static bfd_reloc_status_type

mips_generic_reloc (abfd,

                    reloc_entry,

                    symbol,

                    data,

                    input_section,

                    output_bfd,

                    error_message)

     bfd *abfd ATTRIBUTE_UNUSED;

     arelent *reloc_entry;

     asymbol *symbol;

     PTR data ATTRIBUTE_UNUSED;

     asection *input_section;

     bfd *output_bfd;

     char **error_message ATTRIBUTE_UNUSED;

{

  if (output_bfd != (bfd *) NULL

      && (symbol->flags & BSF_SECTION_SYM) == 0

      && reloc_entry->addend == 0)

    {

      reloc_entry->address += input_section->output_offset;

      return bfd_reloc_ok;

    }

  return bfd_reloc_continue;

}

/* Do a REFHI relocation.  This has to be done in combination with a

   REFLO reloc, because there is a carry from the REFLO to the REFHI.

   Here we just save the information we need; we do the actual

   relocation when we see the REFLO.  MIPS ECOFF requires that the

   REFLO immediately follow the REFHI.  As a GNU extension, we permit

   an arbitrary number of HI relocs to be associated with a single LO

   reloc.  This extension permits gcc to output the HI and LO relocs

   itself.  */

struct mips_hi

{

  struct mips_hi *next;

  bfd_byte *addr;

  bfd_vma addend;

};

/* FIXME: This should not be a static variable.  */

static struct mips_hi *mips_refhi_list;

static bfd_reloc_status_type

mips_refhi_reloc (abfd,

                  reloc_entry,

                  symbol,

                  data,

                  input_section,

                  output_bfd,

                  error_message)

     bfd *abfd ATTRIBUTE_UNUSED;

     arelent *reloc_entry;

     asymbol *symbol;

     PTR data;

     asection *input_section;

     bfd *output_bfd;

     char **error_message ATTRIBUTE_UNUSED;

{

  bfd_reloc_status_type ret;

  bfd_vma relocation;

  struct mips_hi *n;

  /* If we're relocating, and this an external symbol, we don't want

     to change anything.  */

  if (output_bfd != (bfd *) NULL

      && (symbol->flags & BSF_SECTION_SYM) == 0

      && reloc_entry->addend == 0)

    {

      reloc_entry->address += input_section->output_offset;

      return bfd_reloc_ok;

    }

  ret = bfd_reloc_ok;

  if (bfd_is_und_section (symbol->section)

      && output_bfd == (bfd *) NULL)

    ret = bfd_reloc_undefined;

  if (bfd_is_com_section (symbol->section))

    relocation = 0;

  else

    relocation = symbol->value;

  relocation += symbol->section->output_section->vma;

  relocation += symbol->section->output_offset;

  relocation += reloc_entry->addend;

  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))

    return bfd_reloc_outofrange;

  /* Save the information, and let REFLO do the actual relocation.  */

  n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);

  if (n == NULL)

    return bfd_reloc_outofrange;

  n->addr = (bfd_byte *) data + reloc_entry->address;

  n->addend = relocation;

  n->next = mips_refhi_list;

  mips_refhi_list = n;

  if (output_bfd != (bfd *) NULL)

    reloc_entry->address += input_section->output_offset;

  return ret;

}

/* Do a REFLO relocation.  This is a straightforward 16 bit inplace

   relocation; this function exists in order to do the REFHI

   relocation described above.  */

static bfd_reloc_status_type

mips_reflo_reloc (abfd,

                  reloc_entry,

                  symbol,

                  data,

                  input_section,

                  output_bfd,

                  error_message)

     bfd *abfd;

     arelent *reloc_entry;

     asymbol *symbol;

     PTR data;

     asection *input_section;

     bfd *output_bfd;

     char **error_message;

{

  if (mips_refhi_list != NULL)

    {

      struct mips_hi *l;

      l = mips_refhi_list;

      while (l != NULL)

        {

          unsigned long insn;

          unsigned long val;

          unsigned long vallo;

          struct mips_hi *next;

          /* Do the REFHI relocation.  Note that we actually don't

             need to know anything about the REFLO itself, except

             where to find the low 16 bits of the addend needed by the

             REFHI.  */

          insn = bfd_get_32 (abfd, l->addr);

          vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)

                   & 0xffff);

          val = ((insn & 0xffff) << 16) + vallo;

          val += l->addend;

          /* The low order 16 bits are always treated as a signed

             value.  Therefore, a negative value in the low order bits

             requires an adjustment in the high order bits.  We need

             to make this adjustment in two ways: once for the bits we

             took from the data, and once for the bits we are putting

             back in to the data.  */

          if ((vallo & 0x8000) != 0)

            val -= 0x10000;

          if ((val & 0x8000) != 0)

            val += 0x10000;

          insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);

          bfd_put_32 (abfd, (bfd_vma) insn, l->addr);

          next = l->next;

          free (l);

          l = next;

        }

      mips_refhi_list = NULL;

    }

  /* Now do the REFLO reloc in the usual way.  */

  return mips_generic_reloc (abfd, reloc_entry, symbol, data,

                              input_section, output_bfd, error_message);

}

/* Do a GPREL relocation.  This is a 16 bit value which must become

   the offset from the gp register.  */

static bfd_reloc_status_type

mips_gprel_reloc (abfd,

                  reloc_entry,

                  symbol,

                  data,

                  input_section,

                  output_bfd,

                  error_message)

     bfd *abfd;

     arelent *reloc_entry;

     asymbol *symbol;

     PTR data;

     asection *input_section;

     bfd *output_bfd;

     char **error_message;

{

  bfd_boolean relocatable;

  bfd_vma gp;

  bfd_vma relocation;

  unsigned long val;

  unsigned long insn;

  /* If we're relocating, and this is an external symbol with no

     addend, we don't want to change anything.  We will only have an

     addend if this is a newly created reloc, not read from an ECOFF

     file.  */

  if (output_bfd != (bfd *) NULL

      && (symbol->flags & BSF_SECTION_SYM) == 0

      && reloc_entry->addend == 0)

    {

      reloc_entry->address += input_section->output_offset;

      return bfd_reloc_ok;

    }

  if (output_bfd != (bfd *) NULL)

    relocatable = TRUE;

  else

    {

      relocatable = FALSE;

      output_bfd = symbol->section->output_section->owner;

    }

  if (bfd_is_und_section (symbol->section) && ! relocatable)

    return bfd_reloc_undefined;

  /* We have to figure out the gp value, so that we can adjust the

     symbol value correctly.  We look up the symbol _gp in the output

     BFD.  If we can't find it, we're stuck.  We cache it in the ECOFF

     target data.  We don't need to adjust the symbol value for an

     external symbol if we are producing relocatable output.  */

  gp = _bfd_get_gp_value (output_bfd);

  if (gp == 0

      && (! relocatable

          || (symbol->flags & BSF_SECTION_SYM) != 0))

    {

      if (relocatable)

        {

          /* Make up a value.  */

          gp = symbol->section->output_section->vma + 0x4000;

          _bfd_set_gp_value (output_bfd, gp);

        }

      else

        {

          unsigned int count;

          asymbol **sym;

          unsigned int i;

          count = bfd_get_symcount (output_bfd);

          sym = bfd_get_outsymbols (output_bfd);

          if (sym == (asymbol **) NULL)

            i = count;

          else

            {

              for (i = 0; i < count; i++, sym++)

                {

                  register const char *name;

                  name = bfd_asymbol_name (*sym);

                  if (*name == '_' && strcmp (name, "_gp") == 0)

                    {

                      gp = bfd_asymbol_value (*sym);

                      _bfd_set_gp_value (output_bfd, gp);

                      break;

                    }

                }

            }

          if (i >= count)

            {

              /* Only get the error once.  */

              gp = 4;

              _bfd_set_gp_value (output_bfd, gp);

              *error_message =

                (char *) _("GP relative relocation when _gp not defined");

              return bfd_reloc_dangerous;

            }

        }

    }

  if (bfd_is_com_section (symbol->section))

    relocation = 0;

  else

    relocation = symbol->value;

  relocation += symbol->section->output_section->vma;