Back to index

cell-binutils  2.17cvs20070401
Defines | Functions | Variables
coff-i386.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "coff/i386.h"
#include "coff/internal.h"
#include "libcoff.h"
#include "coffcode.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER   (2)
#define COFF_PAGE_SIZE   0x1000
#define DOIT(x)   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
#define PCRELOFFSET   FALSE
#define SELECT_RELOC(x, howto)   { x.r_type = howto->type; }
#define BADMAG(x)   I386BADMAG(x)
#define I386   1 /* Customize coffcode.h */
#define RTYPE2HOWTO(cache_ptr, dst)
#define BSS_NOLOAD_IS_SHARED_LIBRARY
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)
#define coff_relocate_section   _bfd_coff_generic_relocate_section
#define coff_bfd_reloc_type_lookup   coff_i386_reloc_type_lookup
#define coff_bfd_reloc_name_lookup   coff_i386_reloc_name_lookup
#define coff_rtype_to_howto   coff_i386_rtype_to_howto

Functions

static bfd_reloc_status_type
coff_i386_reloc 
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **))
static reloc_howto_type
*coff_i386_rtype_to_howto 
PARAMS ((bfd *, asection *, struct internal_reloc *, struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *))
static reloc_howto_type
*coff_i386_reloc_type_lookup 
PARAMS ((bfd *, bfd_reloc_code_real_type))
static bfd_reloc_status_type coff_i386_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, PTR data, input_section, bfd *output_bfd, error_message)
static reloc_howto_type * coff_i386_rtype_to_howto (abfd, asection *sec, struct internal_reloc *rel, struct coff_link_hash_entry *h, struct internal_syment *sym, bfd_vma *addendp)
static reloc_howto_type * coff_i386_reloc_type_lookup (abfd, bfd_reloc_code_real_type code)
static reloc_howto_type * coff_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)

Variables

static reloc_howto_type howto_table []
const bfd_target i386coff_vec

Define Documentation

#define BADMAG (   x)    I386BADMAG(x)

Definition at line 349 of file coff-i386.c.

Definition at line 361 of file coff-i386.c.

#define CALC_ADDEND (   abfd,
  ptr,
  reloc,
  cache_ptr 
)
Value:
{                                                       \
    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;     \
    if (ptr && bfd_asymbol_bfd (ptr) != abfd)                  \
      coffsym = (obj_symbols (abfd)                            \
                + (cache_ptr->sym_ptr_ptr - symbols));         \
    else if (ptr)                                       \
      coffsym = coff_symbol_from (abfd, ptr);                  \
    if (coffsym != (coff_symbol_type *) NULL                   \
       && coffsym->native->u.syment.n_scnum == 0)              \
      cache_ptr->addend = - coffsym->native->u.syment.n_value; \
    else if (ptr && bfd_asymbol_bfd (ptr) == abfd              \
            && ptr->section != (asection *) NULL)              \
      cache_ptr->addend = - (ptr->section->vma + ptr->value);  \
    else                                                \
      cache_ptr->addend = 0;                                   \
    if (ptr && howto_table[reloc.r_type].pc_relative)          \
      cache_ptr->addend += asect->vma;                         \
  }

Definition at line 376 of file coff-i386.c.

Definition at line 549 of file coff-i386.c.

Definition at line 548 of file coff-i386.c.

Definition at line 50 of file coff-i386.c.

#define COFF_PAGE_SIZE   0x1000

Definition at line 53 of file coff-i386.c.

Definition at line 402 of file coff-i386.c.

Definition at line 596 of file coff-i386.c.

#define DOIT (   x)    x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
#define I386   1 /* Customize coffcode.h */

Definition at line 350 of file coff-i386.c.

#define PCRELOFFSET   FALSE

Definition at line 198 of file coff-i386.c.

#define RTYPE2HOWTO (   cache_ptr,
  dst 
)
Value:
((cache_ptr)->howto =                                                 \
   ((dst)->r_type < sizeof (howto_table) / sizeof (howto_table[0])    \
    ? howto_table + (dst)->r_type                              \
    : NULL))

Definition at line 352 of file coff-i386.c.

#define SELECT_RELOC (   x,
  howto 
)    { x.r_type = howto->type; }

Definition at line 348 of file coff-i386.c.


Function Documentation

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

Definition at line 65 of file coff-i386.c.

{
  symvalue diff;

#ifndef COFF_WITH_PE
  if (output_bfd == (bfd *) NULL)
    return bfd_reloc_continue;
#endif

  if (bfd_is_com_section (symbol->section))
    {
#ifndef COFF_WITH_PE
      /* We are relocating a common symbol.  The current value in the
        object file is ORIG + OFFSET, where ORIG is the value of the
        common symbol as seen by the object file when it was compiled
        (this may be zero if the symbol was undefined) and OFFSET is
        the offset into the common symbol (normally zero, but may be
        non-zero when referring to a field in a common structure).
        ORIG is the negative of reloc_entry->addend, which is set by
        the CALC_ADDEND macro below.  We want to replace the value in
        the object file with NEW + OFFSET, where NEW is the value of
        the common symbol which we are going to put in the final
        object file.  NEW is symbol->value.  */
      diff = symbol->value + reloc_entry->addend;
#else
      /* In PE mode, we do not offset the common symbol.  */
      diff = reloc_entry->addend;
#endif
    }
  else
    {
      /* For some reason bfd_perform_relocation always effectively
        ignores the addend for a COFF target when producing
        relocatable output.  This seems to be always wrong for 386
        COFF, so we handle the addend here instead.  */
#ifdef COFF_WITH_PE
      if (output_bfd == (bfd *) NULL)
       {
         reloc_howto_type *howto = reloc_entry->howto;

         /* Although PC relative relocations are very similar between
            PE and non-PE formats, but they are off by 1 << howto->size
            bytes. For the external relocation, PE is very different
            from others. See md_apply_fix3 () in gas/config/tc-i386.c.
            When we link PE and non-PE object files together to
            generate a non-PE executable, we have to compensate it
            here.  */
         if (howto->pc_relative && howto->pcrel_offset)
           diff = -(1 << howto->size);
         else if (symbol->flags & BSF_WEAK)
           diff = reloc_entry->addend - symbol->value;
         else
           diff = -reloc_entry->addend;
       }
      else
#endif
       diff = reloc_entry->addend;
    }

#ifdef COFF_WITH_PE
  /* FIXME: How should this case be handled?  */
  if (reloc_entry->howto->type == R_IMAGEBASE
      && output_bfd != NULL
      && bfd_get_flavour(output_bfd) == bfd_target_coff_flavour)
    diff -= pe_data (output_bfd)->pe_opthdr.ImageBase;
#endif

#define DOIT(x) \
  x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))

    if (diff != 0)
      {
       reloc_howto_type *howto = reloc_entry->howto;
       unsigned char *addr = (unsigned char *) data + reloc_entry->address;

       switch (howto->size)
         {
         case 0:
           {
             char x = bfd_get_8 (abfd, addr);
             DOIT (x);
             bfd_put_8 (abfd, x, addr);
           }
           break;

         case 1:
           {
             short x = bfd_get_16 (abfd, addr);
             DOIT (x);
             bfd_put_16 (abfd, (bfd_vma) x, addr);
           }
           break;

         case 2:
           {
             long x = bfd_get_32 (abfd, addr);
             DOIT (x);
             bfd_put_32 (abfd, (bfd_vma) x, addr);
           }
           break;

         default:
           abort ();
         }
      }

  /* Now let bfd_perform_relocation finish everything up.  */
  return bfd_reloc_continue;
}
static reloc_howto_type* coff_i386_reloc_name_lookup ( bfd *abfd  ATTRIBUTE_UNUSED,
const char *  r_name 
) [static]

Definition at line 583 of file coff-i386.c.

{
  unsigned int i;

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

  return NULL;
}

Here is the call graph for this function:

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

Definition at line 552 of file coff-i386.c.

{
  switch (code)
    {
    case BFD_RELOC_RVA:
      return howto_table + R_IMAGEBASE;
    case BFD_RELOC_32:
      return howto_table + R_DIR32;
    case BFD_RELOC_32_PCREL:
      return howto_table + R_PCRLONG;
    case BFD_RELOC_16:
      return howto_table + R_RELWORD;
    case BFD_RELOC_16_PCREL:
      return howto_table + R_PCRWORD;
    case BFD_RELOC_8:
      return howto_table + R_RELBYTE;
    case BFD_RELOC_8_PCREL:
      return howto_table + R_PCRBYTE;
#ifdef COFF_WITH_PE
    case BFD_RELOC_32_SECREL:
      return howto_table + R_SECREL32;
#endif
    default:
      BFD_FAIL ();
      return 0;
    }
}
static reloc_howto_type* coff_i386_rtype_to_howto ( abfd  ,
asection sec,
struct internal_reloc rel,
struct coff_link_hash_entry h,
struct internal_syment sym,
bfd_vma addendp 
) [static]

Definition at line 442 of file coff-i386.c.

{
  reloc_howto_type *howto;

  if (rel->r_type > sizeof (howto_table) / sizeof (howto_table[0]))
    {
      bfd_set_error (bfd_error_bad_value);
      return NULL;
    }

  howto = howto_table + rel->r_type;

#ifdef COFF_WITH_PE
  /* Cancel out code in _bfd_coff_generic_relocate_section.  */
  *addendp = 0;
#endif

  if (howto->pc_relative)
    *addendp += sec->vma;

  if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
    {
      /* This is a common symbol.  The section contents include the
        size (sym->n_value) as an addend.  The relocate_section
        function will be adding in the final value of the symbol.  We
        need to subtract out the current size in order to get the
        correct result.  */

      BFD_ASSERT (h != NULL);

#ifndef COFF_WITH_PE
      /* I think we *do* want to bypass this.  If we don't, I have
        seen some data parameters get the wrong relocation address.
        If I link two versions with and without this section bypassed
        and then do a binary comparison, the addresses which are
        different can be looked up in the map.  The case in which
        this section has been bypassed has addresses which correspond
        to values I can find in the map.  */
      *addendp -= sym->n_value;
#endif
    }

#ifndef COFF_WITH_PE
  /* If the output symbol is common (in which case this must be a
     relocatable link), we need to add in the final size of the
     common symbol.  */
  if (h != NULL && h->root.type == bfd_link_hash_common)
    *addendp += h->root.u.c.size;
#endif

#ifdef COFF_WITH_PE
  if (howto->pc_relative)
    {
      *addendp -= 4;

      /* If the symbol is defined, then the generic code is going to
         add back the symbol value in order to cancel out an
         adjustment it made to the addend.  However, we set the addend
         to 0 at the start of this function.  We need to adjust here,
         to avoid the adjustment the generic code will make.  FIXME:
         This is getting a bit hackish.  */
      if (sym != NULL && sym->n_scnum != 0)
       *addendp -= sym->n_value;
    }

  if (rel->r_type == R_IMAGEBASE
      && (bfd_get_flavour(sec->output_section->owner)
         == bfd_target_coff_flavour))
    {
      *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
    }

  if (rel->r_type == R_SECREL32)
    {
      bfd_vma osect_vma;

      if (h && (h->type == bfd_link_hash_defined
              || h->type == bfd_link_hash_defweak))
       osect_vma = h->root.u.def.section->output_section->vma;
      else
       {
         asection *sec;
         int i;

         /* Sigh, the only way to get the section to offset against
            is to find it the hard way.  */

         for (sec = abfd->sections, i = 1; i < sym->n_scnum; i++)
           sec = sec->next;

         osect_vma = sec->output_section->vma;
       }

      *addendp -= osect_vma;
    }
#endif

  return howto;
}

Here is the call graph for this function:

static bfd_reloc_status_type coff_i386_reloc PARAMS ( (bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)  ) [static]
static reloc_howto_type* coff_i386_reloc_type_lookup PARAMS ( (bfd *, bfd_reloc_code_real_type ) [static]

Variable Documentation

reloc_howto_type howto_table[] [static]

Definition at line 201 of file coff-i386.c.

Definition at line 628 of file coff-i386.c.