Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Functions | Variables
coff-mips.c File Reference
#include "bfd.h"
#include "sysdep.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"
#include "coffswap.h"
#include "ecoffswap.h"

Go to the source code of this file.

Classes

struct  mips_hi

Defines

#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
#define ECOFF_32
#define MIPS_HOWTO_COUNT   (sizeof mips_howto_table / sizeof mips_howto_table[0])
#define _bfd_ecoff_bfd_reloc_type_lookup   mips_bfd_reloc_type_lookup
#define _bfd_ecoff_bfd_reloc_name_lookup   mips_bfd_reloc_name_lookup
#define _bfd_ecoff_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
#define _bfd_ecoff_get_section_contents_in_window   _bfd_generic_get_section_contents_in_window
#define _bfd_ecoff_bfd_relax_section   bfd_generic_relax_section
#define _bfd_ecoff_bfd_gc_sections   bfd_generic_gc_sections
#define _bfd_ecoff_bfd_merge_sections   bfd_generic_merge_sections
#define _bfd_ecoff_bfd_is_group_section   bfd_generic_is_group_section
#define _bfd_ecoff_bfd_discard_group   bfd_generic_discard_group
#define _bfd_ecoff_section_already_linked   _bfd_generic_section_already_linked

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 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))
static bfd_boolean mips_ecoff_bad_format_hook (bfd *abfd, PTR filehdr)
static void mips_ecoff_swap_reloc_in (bfd *abfd, PTR ext_ptr, struct internal_reloc *intern)
static void mips_ecoff_swap_reloc_out (bfd *abfd, const struct internal_reloc *intern, PTR dst)
static void mips_adjust_reloc_in (bfd *abfd, const struct internal_reloc *intern, arelent *rptr)
static void mips_adjust_reloc_out (abfd, rel, intern)
static bfd_reloc_status_type mips_generic_reloc (abfd, arelent *reloc_entry, asymbol *symbol, data, asection *input_section, bfd *output_bfd, error_message)
static bfd_reloc_status_type mips_refhi_reloc (abfd, arelent *reloc_entry, asymbol *symbol, PTR data, asection *input_section, bfd *output_bfd, error_message)
static bfd_reloc_status_type mips_reflo_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, PTR data, asection *input_section, bfd *output_bfd, char **error_message)
static bfd_reloc_status_type mips_gprel_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, PTR data, asection *input_section, bfd *output_bfd, char **error_message)
static reloc_howto_type * mips_bfd_reloc_type_lookup (abfd, bfd_reloc_code_real_type code)
static reloc_howto_type * mips_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
static void mips_relocate_hi (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 (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd, asection *input_section, bfd_byte *contents, PTR external_relocs)

Variables

static reloc_howto_type mips_howto_table []
static struct mips_himips_refhi_list
static struct ecoff_backend_data
const bfd_target ecoff_big_vec
const bfd_target ecoff_little_vec
const bfd_target ecoff_biglittle_vec

Class Documentation

struct mips_hi

Definition at line 447 of file coff-mips.c.

Collaboration diagram for mips_hi:
Class Members
bfd_vma addend
bfd_byte * addr
struct mips_hi * next

Define Documentation

Definition at line 1414 of file coff-mips.c.

Definition at line 1408 of file coff-mips.c.

Definition at line 1397 of file coff-mips.c.

Definition at line 1413 of file coff-mips.c.

Definition at line 1411 of file coff-mips.c.

Definition at line 1405 of file coff-mips.c.

Definition at line 1394 of file coff-mips.c.

Definition at line 1393 of file coff-mips.c.

Definition at line 1401 of file coff-mips.c.

Definition at line 1415 of file coff-mips.c.

#define coff_swap_aouthdr_in   mips_ecoff_swap_aouthdr_in

Definition at line 83 of file coff-mips.c.

#define coff_swap_aouthdr_out   mips_ecoff_swap_aouthdr_out

Definition at line 84 of file coff-mips.c.

#define coff_swap_filehdr_in   mips_ecoff_swap_filehdr_in

Definition at line 81 of file coff-mips.c.

#define coff_swap_filehdr_out   mips_ecoff_swap_filehdr_out

Definition at line 82 of file coff-mips.c.

#define coff_swap_scnhdr_in   mips_ecoff_swap_scnhdr_in

Definition at line 85 of file coff-mips.c.

#define coff_swap_scnhdr_out   mips_ecoff_swap_scnhdr_out

Definition at line 86 of file coff-mips.c.

#define ECOFF_32

Definition at line 90 of file coff-mips.c.

#define MIPS_HOWTO_COUNT   (sizeof mips_howto_table / sizeof mips_howto_table[0])

Definition at line 248 of file coff-mips.c.

#define MIPSECOFF

Definition at line 77 of file coff-mips.c.

#define NO_COFF_LINENOS

Definition at line 80 of file coff-mips.c.

#define NO_COFF_RELOCS

Definition at line 78 of file coff-mips.c.

#define NO_COFF_SYMBOLS

Definition at line 79 of file coff-mips.c.


Function Documentation

static void mips_adjust_reloc_in ( bfd abfd,
const struct internal_reloc intern,
arelent rptr 
) [static]

Definition at line 368 of file coff-mips.c.

{
  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];
}
static void mips_adjust_reloc_out ( abfd  ,
rel  ,
intern   
) [static]

Definition at line 393 of file coff-mips.c.

{
}
static reloc_howto_type* mips_bfd_reloc_name_lookup ( bfd *abfd  ATTRIBUTE_UNUSED,
const char *  r_name 
) [static]

Definition at line 774 of file coff-mips.c.

{
  unsigned int i;

  for (i = 0;
       i < sizeof (mips_howto_table) / sizeof (mips_howto_table[0]);
       i++)
    if (mips_howto_table[i].name != NULL
       && strcasecmp (mips_howto_table[i].name, r_name) == 0)
      return &mips_howto_table[i];

  return NULL;
}

Here is the call graph for this function:

static reloc_howto_type* mips_bfd_reloc_type_lookup ( abfd  ,
bfd_reloc_code_real_type  code 
) [static]

Definition at line 733 of file coff-mips.c.

{
  int mips_type;

  switch (code)
    {
    case BFD_RELOC_16:
      mips_type = MIPS_R_REFHALF;
      break;
    case BFD_RELOC_32:
    case BFD_RELOC_CTOR:
      mips_type = MIPS_R_REFWORD;
      break;
    case BFD_RELOC_MIPS_JMP:
      mips_type = MIPS_R_JMPADDR;
      break;
    case BFD_RELOC_HI16_S:
      mips_type = MIPS_R_REFHI;
      break;
    case BFD_RELOC_LO16:
      mips_type = MIPS_R_REFLO;
      break;
    case BFD_RELOC_GPREL16:
      mips_type = MIPS_R_GPREL;
      break;
    case BFD_RELOC_MIPS_LITERAL:
      mips_type = MIPS_R_LITERAL;
      break;
    case BFD_RELOC_16_PCREL_S2:
      mips_type = MIPS_R_PCREL16;
      break;
    default:
      return (reloc_howto_type *) NULL;
    }

  return &mips_howto_table[mips_type];
}
static bfd_boolean mips_ecoff_bad_format_hook ( bfd abfd,
PTR  filehdr 
) [static]

Definition at line 254 of file coff-mips.c.

{
  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;
    }
}
static void mips_ecoff_swap_reloc_in ( bfd abfd,
PTR  ext_ptr,
struct internal_reloc intern 
) [static]

Definition at line 288 of file coff-mips.c.

{
  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;
    }
}

Here is the caller graph for this function:

static void mips_ecoff_swap_reloc_out ( bfd abfd,
const struct internal_reloc intern,
PTR  dst 
) [static]

Definition at line 327 of file coff-mips.c.

{
  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));
    }
}

Here is the caller graph for this function:

static bfd_reloc_status_type mips_generic_reloc ( abfd  ,
arelent reloc_entry,
asymbol symbol,
data  ,
asection input_section,
bfd output_bfd,
error_message   
) [static]

Definition at line 412 of file coff-mips.c.

{
  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;
}

Here is the caller graph for this function:

static bfd_reloc_status_type mips_gprel_reloc ( bfd abfd,
arelent reloc_entry,
asymbol symbol,
PTR  data,
asection input_section,
bfd output_bfd,
char **  error_message 
) [static]

Definition at line 593 of file coff-mips.c.

{
  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;
  relocation += symbol->section->output_offset;

  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
    return bfd_reloc_outofrange;

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

  /* Set val to the offset into the section or symbol.  */
  val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
  if (val & 0x8000)
    val -= 0x10000;

  /* Adjust val for the final section location and GP value.  If we
     are producing relocatable output, we don't want to do this for
     an external symbol.  */
  if (! relocatable
      || (symbol->flags & BSF_SECTION_SYM) != 0)
    val += relocation - gp;

  insn = (insn &~ (unsigned) 0xffff) | (val & 0xffff);
  bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + reloc_entry->address);

  if (relocatable)
    reloc_entry->address += input_section->output_offset;

  /* Make sure it fit in 16 bits.  */
  if ((long) val >= 0x8000 || (long) val < -0x8000)
    return bfd_reloc_overflow;

  return bfd_reloc_ok;
}

Here is the call graph for this function:

static bfd_reloc_status_type mips_refhi_reloc ( abfd  ,
arelent reloc_entry,
asymbol symbol,
PTR  data,
asection input_section,
bfd output_bfd,
error_message   
) [static]

Definition at line 459 of file coff-mips.c.

{
  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;
}

Here is the call graph for this function:

static bfd_reloc_status_type mips_reflo_reloc ( bfd abfd,
arelent reloc_entry,
asymbol symbol,
PTR  data,
asection input_section,
bfd output_bfd,
char **  error_message 
) [static]

Definition at line 525 of file coff-mips.c.

{
  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);
}

Here is the call graph for this function:

static void mips_relocate_hi ( struct internal_reloc refhi,
struct internal_reloc reflo,
bfd input_bfd,
asection input_section,
bfd_byte contents,
bfd_vma  relocation 
) [static]

Definition at line 795 of file coff-mips.c.

{
  unsigned long insn;
  unsigned long val;
  unsigned long vallo;

  if (refhi == NULL)
    return;

  insn = bfd_get_32 (input_bfd,
                   contents + refhi->r_vaddr - input_section->vma);
  if (reflo == NULL)
    vallo = 0;
  else
    vallo = (bfd_get_32 (input_bfd,
                      contents + reflo->r_vaddr - input_section->vma)
            & 0xffff);

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

  /* 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 (input_bfd, (bfd_vma) insn,
             contents + refhi->r_vaddr - input_section->vma);
}

Here is the caller graph for this function:

static bfd_boolean mips_relocate_section ( bfd output_bfd,
struct bfd_link_info info,
bfd input_bfd,
asection input_section,
bfd_byte contents,
PTR  external_relocs 
) [static]

Definition at line 842 of file coff-mips.c.

{
  asection **symndx_to_section;
  struct ecoff_link_hash_entry **sym_hashes;
  bfd_vma gp;
  bfd_boolean gp_undefined;
  struct external_reloc *ext_rel;
  struct external_reloc *ext_rel_end;
  unsigned int i;
  bfd_boolean got_lo;
  struct internal_reloc lo_int_rel;
  bfd_size_type amt;

  BFD_ASSERT (input_bfd->xvec->byteorder
             == output_bfd->xvec->byteorder);

  /* We keep a table mapping the symndx found in an internal reloc to
     the appropriate section.  This is faster than looking up the
     section by name each time.  */
  symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
  if (symndx_to_section == (asection **) NULL)
    {
      amt = NUM_RELOC_SECTIONS * sizeof (asection *);
      symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
      if (!symndx_to_section)
       return FALSE;

      symndx_to_section[RELOC_SECTION_NONE] = NULL;
      symndx_to_section[RELOC_SECTION_TEXT] =
       bfd_get_section_by_name (input_bfd, ".text");
      symndx_to_section[RELOC_SECTION_RDATA] =
       bfd_get_section_by_name (input_bfd, ".rdata");
      symndx_to_section[RELOC_SECTION_DATA] =
       bfd_get_section_by_name (input_bfd, ".data");
      symndx_to_section[RELOC_SECTION_SDATA] =
       bfd_get_section_by_name (input_bfd, ".sdata");
      symndx_to_section[RELOC_SECTION_SBSS] =
       bfd_get_section_by_name (input_bfd, ".sbss");
      symndx_to_section[RELOC_SECTION_BSS] =
       bfd_get_section_by_name (input_bfd, ".bss");
      symndx_to_section[RELOC_SECTION_INIT] =
       bfd_get_section_by_name (input_bfd, ".init");
      symndx_to_section[RELOC_SECTION_LIT8] =
       bfd_get_section_by_name (input_bfd, ".lit8");
      symndx_to_section[RELOC_SECTION_LIT4] =
       bfd_get_section_by_name (input_bfd, ".lit4");
      symndx_to_section[RELOC_SECTION_XDATA] = NULL;
      symndx_to_section[RELOC_SECTION_PDATA] = NULL;
      symndx_to_section[RELOC_SECTION_FINI] =
       bfd_get_section_by_name (input_bfd, ".fini");
      symndx_to_section[RELOC_SECTION_LITA] = NULL;
      symndx_to_section[RELOC_SECTION_ABS] = NULL;

      ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
    }

  sym_hashes = ecoff_data (input_bfd)->sym_hashes;

  gp = _bfd_get_gp_value (output_bfd);
  if (gp == 0)
    gp_undefined = TRUE;
  else
    gp_undefined = FALSE;

  got_lo = FALSE;

  ext_rel = (struct external_reloc *) external_relocs;
  ext_rel_end = ext_rel + input_section->reloc_count;
  for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
    {
      struct internal_reloc int_rel;
      bfd_boolean use_lo = FALSE;
      bfd_vma addend;
      reloc_howto_type *howto;
      struct ecoff_link_hash_entry *h = NULL;
      asection *s = NULL;
      bfd_vma relocation;
      bfd_reloc_status_type r;

      if (! got_lo)
       mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
      else
       {
         int_rel = lo_int_rel;
         got_lo = FALSE;
       }

      BFD_ASSERT (int_rel.r_type
                < sizeof mips_howto_table / sizeof mips_howto_table[0]);

      /* The REFHI reloc requires special handling.  It must be followed
        by a REFLO reloc, and the addend is formed from both relocs.  */
      if (int_rel.r_type == MIPS_R_REFHI)
       {
         struct external_reloc *lo_ext_rel;

         /* As a GNU extension, permit an arbitrary number of REFHI
             relocs before the REFLO reloc.  This permits gcc to emit
            the HI and LO relocs itself.  */
         for (lo_ext_rel = ext_rel + 1;
              lo_ext_rel < ext_rel_end;
              lo_ext_rel++)
           {
             mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
                                   &lo_int_rel);
             if (lo_int_rel.r_type != int_rel.r_type)
              break;
           }

         if (lo_ext_rel < ext_rel_end
             && lo_int_rel.r_type == MIPS_R_REFLO
             && int_rel.r_extern == lo_int_rel.r_extern
             && int_rel.r_symndx == lo_int_rel.r_symndx)
           {
             use_lo = TRUE;
             if (lo_ext_rel == ext_rel + 1)
              got_lo = TRUE;
           }
       }

      howto = &mips_howto_table[int_rel.r_type];

      if (int_rel.r_extern)
       {
         h = sym_hashes[int_rel.r_symndx];
         /* If h is NULL, that means that there is a reloc against an
            external symbol which we thought was just a debugging
            symbol.  This should not happen.  */
         if (h == (struct ecoff_link_hash_entry *) NULL)
           abort ();
       }
      else
       {
         if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
           s = NULL;
         else
           s = symndx_to_section[int_rel.r_symndx];

         if (s == (asection *) NULL)
           abort ();
       }

      /* The GPREL reloc uses an addend: the difference in the GP
        values.  */
      if (int_rel.r_type != MIPS_R_GPREL
         && int_rel.r_type != MIPS_R_LITERAL)
       addend = 0;
      else
       {
         if (gp_undefined)
           {
             if (! ((*info->callbacks->reloc_dangerous)
                   (info, _("GP relative relocation used when GP not defined"),
                    input_bfd, input_section,
                    int_rel.r_vaddr - input_section->vma)))
              return FALSE;
             /* Only give the error once per link.  */
             gp = 4;
             _bfd_set_gp_value (output_bfd, gp);
             gp_undefined = FALSE;
           }
         if (! int_rel.r_extern)
           {
             /* This is a relocation against a section.  The current
               addend in the instruction is the difference between
               INPUT_SECTION->vma and the GP value of INPUT_BFD.  We
               must change this to be the difference between the
               final definition (which will end up in RELOCATION)
               and the GP value of OUTPUT_BFD (which is in GP).  */
             addend = ecoff_data (input_bfd)->gp - gp;
           }
         else if (! info->relocatable
                 || h->root.type == bfd_link_hash_defined
                 || h->root.type == bfd_link_hash_defweak)
           {
             /* This is a relocation against a defined symbol.  The
               current addend in the instruction is simply the
               desired offset into the symbol (normally zero).  We
               are going to change this into a relocation against a
               defined symbol, so we want the instruction to hold
               the difference between the final definition of the
               symbol (which will end up in RELOCATION) and the GP
               value of OUTPUT_BFD (which is in GP).  */
             addend = - gp;
           }
         else
           {
             /* This is a relocation against an undefined or common
               symbol.  The current addend in the instruction is
               simply the desired offset into the symbol (normally
               zero).  We are generating relocatable output, and we
               aren't going to define this symbol, so we just leave
               the instruction alone.  */
             addend = 0;
           }
       }

      if (info->relocatable)
       {
         /* We are generating relocatable output, and must convert
            the existing reloc.  */
         if (int_rel.r_extern)
           {
             if ((h->root.type == bfd_link_hash_defined
                 || h->root.type == bfd_link_hash_defweak)
                && ! bfd_is_abs_section (h->root.u.def.section))
              {
                const char *name;

                /* This symbol is defined in the output.  Convert
                   the reloc from being against the symbol to being
                   against the section.  */

                /* Clear the r_extern bit.  */
                int_rel.r_extern = 0;

                /* Compute a new r_symndx value.  */
                s = h->root.u.def.section;
                name = bfd_get_section_name (output_bfd,
                                          s->output_section);

                int_rel.r_symndx = -1;
                switch (name[1])
                  {
                  case 'b':
                    if (strcmp (name, ".bss") == 0)
                     int_rel.r_symndx = RELOC_SECTION_BSS;
                    break;
                  case 'd':
                    if (strcmp (name, ".data") == 0)
                     int_rel.r_symndx = RELOC_SECTION_DATA;
                    break;
                  case 'f':
                    if (strcmp (name, ".fini") == 0)
                     int_rel.r_symndx = RELOC_SECTION_FINI;
                    break;
                  case 'i':
                    if (strcmp (name, ".init") == 0)
                     int_rel.r_symndx = RELOC_SECTION_INIT;
                    break;
                  case 'l':
                    if (strcmp (name, ".lit8") == 0)
                     int_rel.r_symndx = RELOC_SECTION_LIT8;
                    else if (strcmp (name, ".lit4") == 0)
                     int_rel.r_symndx = RELOC_SECTION_LIT4;
                    break;
                  case 'r':
                    if (strcmp (name, ".rdata") == 0)
                     int_rel.r_symndx = RELOC_SECTION_RDATA;
                    break;
                  case 's':
                    if (strcmp (name, ".sdata") == 0)
                     int_rel.r_symndx = RELOC_SECTION_SDATA;
                    else if (strcmp (name, ".sbss") == 0)
                     int_rel.r_symndx = RELOC_SECTION_SBSS;
                    break;
                  case 't':
                    if (strcmp (name, ".text") == 0)
                     int_rel.r_symndx = RELOC_SECTION_TEXT;
                    break;
                  }

                if (int_rel.r_symndx == -1)
                  abort ();

                /* Add the section VMA and the symbol value.  */
                relocation = (h->root.u.def.value
                            + s->output_section->vma
                            + s->output_offset);

                /* For a PC relative relocation, the object file
                   currently holds just the addend.  We must adjust
                   by the address to get the right value.  */
                if (howto->pc_relative)
                  relocation -= int_rel.r_vaddr - input_section->vma;

                h = NULL;
              }
             else
              {
                /* Change the symndx value to the right one for the
                   output BFD.  */
                int_rel.r_symndx = h->indx;
                if (int_rel.r_symndx == -1)
                  {
                    /* This symbol is not being written out.  */
                    if (! ((*info->callbacks->unattached_reloc)
                          (info, h->root.root.string, input_bfd,
                           input_section,
                           int_rel.r_vaddr - input_section->vma)))
                     return FALSE;
                    int_rel.r_symndx = 0;
                  }
                relocation = 0;
              }
           }
         else
           {
             /* This is a relocation against a section.  Adjust the
               value by the amount the section moved.  */
             relocation = (s->output_section->vma
                         + s->output_offset
                         - s->vma);
           }

         relocation += addend;
         addend = 0;

         /* Adjust a PC relative relocation by removing the reference
            to the original address in the section and including the
            reference to the new address.  */
         if (howto->pc_relative)
           relocation -= (input_section->output_section->vma
                        + input_section->output_offset
                        - input_section->vma);

         /* Adjust the contents.  */
         if (relocation == 0)
           r = bfd_reloc_ok;
         else
           {
             if (int_rel.r_type != MIPS_R_REFHI)
              r = _bfd_relocate_contents (howto, input_bfd, relocation,
                                       (contents
                                        + int_rel.r_vaddr
                                        - input_section->vma));
             else
              {
                mips_relocate_hi (&int_rel,
                                use_lo ? &lo_int_rel : NULL,
                                input_bfd, input_section, contents,
                                relocation);
                r = bfd_reloc_ok;
              }
           }

         /* Adjust the reloc address.  */
         int_rel.r_vaddr += (input_section->output_section->vma
                           + input_section->output_offset
                           - input_section->vma);

         /* Save the changed reloc information.  */
         mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
       }
      else
       {
         /* We are producing a final executable.  */
         if (int_rel.r_extern)
           {
             /* This is a reloc against a symbol.  */
             if (h->root.type == bfd_link_hash_defined
                || h->root.type == bfd_link_hash_defweak)
              {
                asection *hsec;

                hsec = h->root.u.def.section;
                relocation = (h->root.u.def.value
                            + hsec->output_section->vma
                            + hsec->output_offset);
              }
             else
              {
                if (! ((*info->callbacks->undefined_symbol)
                      (info, h->root.root.string, input_bfd,
                       input_section,
                       int_rel.r_vaddr - input_section->vma, TRUE)))
                  return FALSE;
                relocation = 0;
              }
           }
         else
           {
             /* This is a reloc against a section.  */
             relocation = (s->output_section->vma
                         + s->output_offset
                         - s->vma);

             /* A PC relative reloc is already correct in the object
               file.  Make it look like a pcrel_offset relocation by
               adding in the start address.  */
             if (howto->pc_relative)
              relocation += int_rel.r_vaddr;
           }

         if (int_rel.r_type != MIPS_R_REFHI)
           r = _bfd_final_link_relocate (howto,
                                     input_bfd,
                                     input_section,
                                     contents,
                                     (int_rel.r_vaddr
                                      - input_section->vma),
                                     relocation,
                                     addend);
         else
           {
             mips_relocate_hi (&int_rel,
                            use_lo ? &lo_int_rel : NULL,
                            input_bfd, input_section, contents,
                            relocation);
             r = bfd_reloc_ok;
           }
       }

      /* MIPS_R_JMPADDR requires peculiar overflow detection.  The
        instruction provides a 28 bit address (the two lower bits are
        implicit zeroes) which is combined with the upper four bits
        of the instruction address.  */
      if (r == bfd_reloc_ok
         && int_rel.r_type == MIPS_R_JMPADDR
         && (((relocation
              + addend
              + (int_rel.r_extern ? 0 : s->vma))
              & 0xf0000000)
             != ((input_section->output_section->vma
                 + input_section->output_offset
                 + (int_rel.r_vaddr - input_section->vma))
                & 0xf0000000)))
       r = bfd_reloc_overflow;

      if (r != bfd_reloc_ok)
       {
         switch (r)
           {
           default:
           case bfd_reloc_outofrange:
             abort ();
           case bfd_reloc_overflow:
             {
              const char *name;

              if (int_rel.r_extern)
                name = NULL;
              else
                name = bfd_section_name (input_bfd, s);
              if (! ((*info->callbacks->reloc_overflow)
                     (info, (h ? &h->root : NULL), name, howto->name,
                     (bfd_vma) 0, input_bfd, input_section,
                     int_rel.r_vaddr - input_section->vma)))
                return FALSE;
             }
             break;
           }
       }
    }

  return TRUE;
}

Here is the call graph for this function:

static void mips_ecoff_swap_reloc_in PARAMS ( (bfd *, PTR, struct internal_reloc *)  ) [static]
static void mips_ecoff_swap_reloc_out PARAMS ( (bfd *, const struct internal_reloc *, PTR ) [static]
static void mips_adjust_reloc_in PARAMS ( (bfd *, const struct internal_reloc *, arelent *)  ) [static]
static void mips_adjust_reloc_out PARAMS ( (bfd *, const arelent *, struct internal_reloc *)  ) [static]
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]
static reloc_howto_type* mips_bfd_reloc_type_lookup PARAMS ( (bfd *, bfd_reloc_code_real_type ) [static]

Variable Documentation

Definition at line 1300 of file coff-mips.c.

Definition at line 1464 of file coff-mips.c.

Definition at line 1507 of file coff-mips.c.

Definition at line 1420 of file coff-mips.c.

reloc_howto_type mips_howto_table[] [static]

Definition at line 95 of file coff-mips.c.

Definition at line 456 of file coff-mips.c.