Back to index

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

Go to the source code of this file.


#define COFF_WITH_pex64
#define BADMAG(x)   AMD64BADMAG(x)
#define COFF_PAGE_SIZE   0x1000
#define DOIT(x)   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
#define SELECT_RELOC(x, howto)   { x.r_type = howto->type; }
#define I386   1 /* Customize coffcode.h */
#define AMD64   1
#define RTYPE2HOWTO(cache_ptr, dst)
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)
#define coff_relocate_section   _bfd_coff_generic_relocate_section
#define coff_bfd_reloc_type_lookup   coff_amd64_reloc_type_lookup
#define coff_bfd_reloc_name_lookup   coff_amd64_reloc_name_lookup
#define coff_rtype_to_howto   coff_amd64_rtype_to_howto
#define amd64coff_object_p   coff_object_p


static bfd_reloc_status_type coff_amd64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, void *data, asection *input_section ATTRIBUTE_UNUSED, bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
static reloc_howto_type * coff_amd64_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, struct internal_reloc *rel, struct coff_link_hash_entry *h, struct internal_syment *sym, bfd_vma *addendp)
static reloc_howto_type * coff_amd64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
static reloc_howto_type * coff_amd64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)


static reloc_howto_type howto_table []
const bfd_target x86_64coff_vec

Define Documentation

#define AMD64   1

Definition at line 448 of file coff-x86_64.c.

Definition at line 718 of file coff-x86_64.c.


Definition at line 39 of file coff-x86_64.c.

#define BADMAG (   x)    AMD64BADMAG(x)

Definition at line 35 of file coff-x86_64.c.

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

#define CALC_ADDEND (   abfd,
{                                                       \
    coff_symbol_type *coffsym = 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 != 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 != 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 474 of file coff-x86_64.c.

Definition at line 637 of file coff-x86_64.c.

Definition at line 636 of file coff-x86_64.c.

Definition at line 43 of file coff-x86_64.c.

#define COFF_PAGE_SIZE   0x1000

Definition at line 47 of file coff-x86_64.c.

Definition at line 502 of file coff-x86_64.c.

Definition at line 692 of file coff-x86_64.c.

#define COFF_WITH_pex64

Definition at line 23 of file coff-x86_64.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 447 of file coff-x86_64.c.


Definition at line 194 of file coff-x86_64.c.


Definition at line 40 of file coff-x86_64.c.

#define RTYPE2HOWTO (   cache_ptr,
((cache_ptr)->howto =                            \
   ((dst)->r_type < ARRAY_SIZE (howto_table))    \
    ? howto_table + (dst)->r_type         \
    : NULL)

Definition at line 450 of file coff-x86_64.c.

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

Definition at line 446 of file coff-x86_64.c.

Function Documentation

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

Definition at line 59 of file coff-x86_64.c.

  symvalue diff;

#if !defined(COFF_WITH_PE)
  if (output_bfd == NULL)
    return bfd_reloc_continue;

  if (bfd_is_com_section (symbol->section))
#if !defined(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;
      /* In PE mode, we do not offset the common symbol.  */
      diff = reloc_entry->addend;
      /* 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.  */
#if defined(COFF_WITH_PE)
      if (output_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-amd64.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;
           diff = -reloc_entry->addend;
       diff = reloc_entry->addend;

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

#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);

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

         case 2:
             long x = bfd_get_32 (abfd, addr);
             DOIT (x);
             bfd_put_32 (abfd, (bfd_vma) x, addr);
         case 4:
             long long x = bfd_get_64 (abfd, addr);
             DOIT (x);
             bfd_put_64 (abfd, (bfd_vma) x, addr);

           abort ();

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

Definition at line 679 of file coff-x86_64.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_amd64_reloc_type_lookup ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_reloc_code_real_type  code 
) [static]

Definition at line 640 of file coff-x86_64.c.

  switch (code)
    case BFD_RELOC_RVA:
      return howto_table + R_AMD64_IMAGEBASE;
    case BFD_RELOC_32:
      return howto_table + R_AMD64_DIR32;
    case BFD_RELOC_64:
      return howto_table + R_AMD64_DIR64;
    case BFD_RELOC_64_PCREL:
      return howto_table + R_AMD64_PCRQUAD;
      /* Fall through.  */
    case BFD_RELOC_32_PCREL:
      return howto_table + R_AMD64_PCRLONG;
    case BFD_RELOC_X86_64_32S:
      return howto_table + R_RELLONG;
    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;
#if defined(COFF_WITH_PE)
    case BFD_RELOC_32_SECREL:
      return howto_table + R_AMD64_SECREL;
      BFD_FAIL ();
      return 0;
static reloc_howto_type* coff_amd64_rtype_to_howto ( bfd *abfd  ATTRIBUTE_UNUSED,
asection sec,
struct internal_reloc rel,
struct coff_link_hash_entry h,
struct internal_syment sym,
bfd_vma addendp 
) [static]

Definition at line 533 of file coff-x86_64.c.

  reloc_howto_type *howto;

  if (rel->r_type > ARRAY_SIZE (howto_table))
      bfd_set_error (bfd_error_bad_value);
      return NULL;
  if (rel->r_type >= R_AMD64_PCRLONG_1 && rel->r_type <= R_AMD64_PCRLONG_5)
      rel->r_vaddr += (bfd_vma)(rel->r_type-R_AMD64_PCRLONG);
      rel->r_type = R_AMD64_PCRLONG;
  howto = howto_table + rel->r_type;

#if defined(COFF_WITH_PE)
  /* Cancel out code in _bfd_coff_generic_relocate_section.  */
  *addendp = 0;

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

#if !defined(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;

#if !defined(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;

#if defined(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_AMD64_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_AMD64_SECREL)
      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;
         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;

  return howto;

Here is the call graph for this function:

Variable Documentation

reloc_howto_type howto_table[] [static]

Definition at line 197 of file coff-x86_64.c.

Definition at line 725 of file coff-x86_64.c.