Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Typedefs | Functions | Variables
coff-mcore.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "coff/mcore.h"
#include "coff/internal.h"
#include "coff/pe.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.

Classes

Defines

#define BADMAG(x)   MCOREBADMAG(x)
#define NUM_ELEM(A)   (sizeof (A) / sizeof (A)[0])
#define TOC_LOAD_ADJUSTMENT   (-32768)
#define TOC_SECTION_NAME   ".private.toc"
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER   2
#define MINUS_ONE   (((bfd_vma)0) - 1)
#define coff_mcore_hash_table(info)   ((mcore_hash_table *) ((info)->hash))
#define HOW2MAP(bfd_rtype, mcore_rtype)   case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype]
#define RTYPE2HOWTO(cache_ptr, dst)   (cache_ptr)->howto = mcore_coff_howto_table + (dst)->r_type;
#define coff_bfd_reloc_type_lookup   mcore_coff_reloc_type_lookup
#define coff_bfd_reloc_name_lookup   mcore_coff_reloc_name_lookup
#define coff_relocate_section   coff_mcore_relocate_section
#define coff_rtype_to_howto   coff_mcore_rtype_to_howto
#define SELECT_RELOC(internal, howto)   {internal.r_type = howto->type;}
#define SWAP_IN_RELOC_OFFSET   H_GET_32
#define SWAP_OUT_RELOC_OFFSET   H_PUT_32
#define COFF_PAGE_SIZE   0x1000

Typedefs

typedef struct
coff_mcore_link_hash_table 
mcore_hash_table

Functions

bfd_boolean
mcore_bfd_coff_final_link 
PARAMS ((bfd *, struct bfd_link_info *))
static bfd_reloc_status_type
mcore_coff_unsupported_reloc 
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **))
static bfd_boolean
coff_mcore_relocate_section 
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, struct internal_reloc *, struct internal_syment *, asection **))
static reloc_howto_type
*mcore_coff_reloc_type_lookup 
PARAMS ((bfd *, bfd_reloc_code_real_type))
static reloc_howto_type
*coff_mcore_rtype_to_howto 
PARAMS ((bfd *, asection *, struct internal_reloc *, struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *))
static void
mcore_emit_base_file_entry 
PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_vma))
static bfd_boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *))
static void mcore_emit_base_file_entry (struct bfd_link_info *info, bfd *output_bfd, asection *input_section, bfd_vma reloc_offset)
static bfd_reloc_status_type mcore_coff_unsupported_reloc (bfd *abfd, arelent *reloc_entry, symbol, data, input_section, output_bfd, error_message)
static reloc_howto_type * mcore_coff_reloc_type_lookup (abfd, bfd_reloc_code_real_type code)
static reloc_howto_type * mcore_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
static reloc_howto_type * coff_mcore_rtype_to_howto (abfd, asection *sec, struct internal_reloc *rel, h, struct internal_syment *sym, bfd_vma *addendp)
static bfd_boolean in_reloc_p (abfd, reloc_howto_type *howto)
static bfd_boolean coff_mcore_relocate_section (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd, asection *input_section, bfd_byte *contents, struct internal_reloc *relocs, struct internal_syment *syms, asection **sections)
 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED,(SEC_CODE|SEC_DATA|SEC_DEBUGGING|SEC_READONLY|SEC_LINK_ONCE|SEC_LINK_DUPLICATES), 0,&TARGET_LITTLE_SYM, COFF_SWAP_TABLE) CREATE_LITTLE_COFF_TARGET_VEC(TARGET_LITTLE_SYM

Variables

static reloc_howto_type mcore_coff_howto_table []
const bfd_target TARGET_LITTLE_SYM
 TARGET_LITTLE_NAME
 D_PAGED
SEC_CODE SEC_DATA
SEC_DEBUGGING SEC_READONLY
SEC_LINK_ONCE 
SEC_LINK_DUPLICATES
SEC_CODE SEC_DATA
SEC_DEBUGGING SEC_READONLY
SEC_LINK_ONCE
TARGET_BIG_SYM

Class Documentation

struct coff_mcore_link_hash_table

Definition at line 204 of file coff-mcore.c.

Collaboration diagram for coff_mcore_link_hash_table:
Class Members
bfd * bfd_of_toc_owner
long int first_thunk_address
long int global_toc_size
long int import_table_size
long int thunk_size

Define Documentation

#define BADMAG (   x)    MCOREBADMAG(x)

Definition at line 33 of file coff-mcore.c.

Definition at line 557 of file coff-mcore.c.

Definition at line 556 of file coff-mcore.c.

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

#define coff_mcore_hash_table (   info)    ((mcore_hash_table *) ((info)->hash))

Definition at line 218 of file coff-mcore.c.

#define COFF_PAGE_SIZE   0x1000

Definition at line 568 of file coff-mcore.c.

Definition at line 558 of file coff-mcore.c.

Definition at line 559 of file coff-mcore.c.

#define HOW2MAP (   bfd_rtype,
  mcore_rtype 
)    case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype]

Definition at line 264 of file coff-mcore.c.

#define MINUS_ONE   (((bfd_vma)0) - 1)

Definition at line 69 of file coff-mcore.c.

#define NUM_ELEM (   A)    (sizeof (A) / sizeof (A)[0])

Definition at line 36 of file coff-mcore.c.

#define RTYPE2HOWTO (   cache_ptr,
  dst 
)    (cache_ptr)->howto = mcore_coff_howto_table + (dst)->r_type;

Definition at line 305 of file coff-mcore.c.

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

Definition at line 561 of file coff-mcore.c.

Definition at line 565 of file coff-mcore.c.

Definition at line 566 of file coff-mcore.c.

#define TOC_LOAD_ADJUSTMENT   (-32768)

Definition at line 61 of file coff-mcore.c.

#define TOC_SECTION_NAME   ".private.toc"

Definition at line 62 of file coff-mcore.c.


Typedef Documentation


Function Documentation

static bfd_boolean coff_mcore_relocate_section ( bfd output_bfd,
struct bfd_link_info info,
bfd input_bfd,
asection input_section,
bfd_byte contents,
struct internal_reloc relocs,
struct internal_syment syms,
asection **  sections 
) [static]

Definition at line 359 of file coff-mcore.c.

{
  struct internal_reloc * rel;
  struct internal_reloc * relend;
  bfd_boolean hihalf;
  bfd_vma hihalf_val;

  /* If we are performing a relocatable link, we don't need to do a
     thing.  The caller will take care of adjusting the reloc
     addresses and symbol indices.  */
  if (info->relocatable)
    return TRUE;

  /* Check if we have the same endianess */
  if (   input_bfd->xvec->byteorder != output_bfd->xvec->byteorder
      && output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
    {
      (*_bfd_error_handler)
       (_("%B: compiled for a %s system and target is %s.\n"),
        input_bfd,
         bfd_big_endian (input_bfd) ? _("big endian") : _("little endian"),
         bfd_big_endian (output_bfd) ? _("big endian") : _("little endian"));

      bfd_set_error (bfd_error_wrong_format);
      return FALSE;
    }

  hihalf = FALSE;
  hihalf_val = 0;

  rel = relocs;
  relend = rel + input_section->reloc_count;

  for (; rel < relend; rel++)
    {
      long                           symndx;
      struct internal_syment *       sym;
      bfd_vma                        val;
      bfd_vma                        addend;
      bfd_reloc_status_type          rstat;
      bfd_byte *                     loc;
      unsigned short                 r_type = rel->r_type;
      reloc_howto_type *             howto = NULL;
      struct coff_link_hash_entry *  h;
      const char *                   my_name;

      symndx = rel->r_symndx;
      loc = contents + rel->r_vaddr - input_section->vma;

      if (symndx == -1)
       {
         h = NULL;
         sym = NULL;
       }
      else
       {
         h = obj_coff_sym_hashes (input_bfd)[symndx];
         sym = syms + symndx;
       }

      addend = 0;

      /* Get the howto and initialise the addend.  */
      howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
                                   sym, & addend);
      if (howto == NULL)
       return FALSE;

      val = 0;

      if (h == NULL)
       {
         if (symndx == -1)
           my_name = "*ABS*";
         else
           {
             asection * sec = sections[symndx];

             val = (sym->n_value
                   + sec->output_section->vma
                   + sec->output_offset);

             if (sym == NULL)
              my_name = "*unknown*";
             else if (   sym->_n._n_n._n_zeroes == 0
                     && sym->_n._n_n._n_offset != 0)
              my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
             else
              {
                static char buf [SYMNMLEN + 1];

                strncpy (buf, sym->_n._n_name, SYMNMLEN);
                buf[SYMNMLEN] = '\0';
                my_name = buf;
              }
           }
       }
      else
       {
         if (   h->root.type == bfd_link_hash_defined
             || h->root.type == bfd_link_hash_defweak)
           {
             asection * sec = h->root.u.def.section;

             val = (h->root.u.def.value
                   + sec->output_section->vma
                   + sec->output_offset);
           }
         else
           {
             if (! ((*info->callbacks->undefined_symbol)
                   (info, h->root.root.string, input_bfd, input_section,
                    rel->r_vaddr - input_section->vma, TRUE)))
              return FALSE;
           }

         my_name = h->root.root.string;
       }

      rstat = bfd_reloc_ok;

      /* Each case must do its own relocation, setting rstat appropriately.  */
      switch (r_type)
       {
       default:
         _bfd_error_handler (_("%B: unsupported relocation type 0x%02x"),
                           input_bfd, r_type);
         bfd_set_error (bfd_error_bad_value);
         return FALSE;

       case IMAGE_REL_MCORE_ABSOLUTE:
         _bfd_error_handler
           (_("Warning: unsupported reloc %s <file %B, section %A>\n"
              "sym %ld (%s), r_vaddr %ld (%lx)"),
            input_bfd, input_section, howto->name,
            rel->r_symndx, my_name, (long) rel->r_vaddr,
            (unsigned long) rel->r_vaddr);
         break;

       case IMAGE_REL_MCORE_PCREL_IMM8BY4:
       case IMAGE_REL_MCORE_PCREL_IMM11BY2:
       case IMAGE_REL_MCORE_PCREL_IMM4BY2:
       case IMAGE_REL_MCORE_PCREL_32:
       case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2:
       case IMAGE_REL_MCORE_ADDR32:
         /* XXX fixme - shouldn't this be like the code for the RVA reloc ? */
         rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
         break;

       case IMAGE_REL_MCORE_RVA:
         rstat = _bfd_final_link_relocate
           (howto, input_bfd,
            input_section, contents, rel->r_vaddr - input_section->vma,
            val, addend);
         break;
       }

      if (info->base_file)
       {
         /* Emit a reloc if the backend thinks it needs it.  */
         if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
            mcore_emit_base_file_entry (info, output_bfd, input_section, rel->r_vaddr);
       }

      switch (rstat)
       {
       default:
         abort ();

       case bfd_reloc_ok:
         break;

       case bfd_reloc_overflow:
         if (! ((*info->callbacks->reloc_overflow)
               (info, (h ? &h->root : NULL), my_name, howto->name,
                (bfd_vma) 0, input_bfd,
                input_section, rel->r_vaddr - input_section->vma)))
           return FALSE;
       }
    }

  return TRUE;
}

Here is the call graph for this function:

static reloc_howto_type* coff_mcore_rtype_to_howto ( abfd  ,
asection sec,
struct internal_reloc rel,
,
struct internal_syment sym,
bfd_vma addendp 
) [static]

Definition at line 309 of file coff-mcore.c.

{
  reloc_howto_type * howto;

  if (rel->r_type >= NUM_ELEM (mcore_coff_howto_table))
    return NULL;

  howto = mcore_coff_howto_table + rel->r_type;

  if (rel->r_type == IMAGE_REL_MCORE_RVA)
    * addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;

  else if (howto->pc_relative)
    {
      * addendp = sec->vma - 2; /* XXX guess - is this right ? */

      /* 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;
    }
  else
    * addendp = 0;

  return howto;
}
static bfd_boolean in_reloc_p ( abfd  ,
reloc_howto_type *  howto 
) [static]

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

{
  return ! howto->pc_relative && howto->type != IMAGE_REL_MCORE_RVA;
}

Here is the caller graph for this function:

static reloc_howto_type* mcore_coff_reloc_name_lookup ( bfd *abfd  ATTRIBUTE_UNUSED,
const char *  r_name 
) [static]

Definition at line 289 of file coff-mcore.c.

{
  unsigned int i;

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

  return NULL;
}

Here is the call graph for this function:

static reloc_howto_type* mcore_coff_reloc_type_lookup ( abfd  ,
bfd_reloc_code_real_type  code 
) [static]
static bfd_reloc_status_type mcore_coff_unsupported_reloc ( bfd abfd,
arelent reloc_entry,
symbol  ,
data  ,
input_section  ,
output_bfd  ,
error_message   
) [static]

Definition at line 243 of file coff-mcore.c.

{
  BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);

  _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"),
                    abfd,
                    reloc_entry->howto->name,
                    reloc_entry->howto->type);

  return bfd_reloc_notsupported;
}
static void mcore_emit_base_file_entry ( struct bfd_link_info info,
bfd output_bfd,
asection input_section,
bfd_vma  reloc_offset 
) [static]

Definition at line 225 of file coff-mcore.c.

{
  bfd_vma addr = reloc_offset
                 - input_section->vma
                 + input_section->output_offset
                 + input_section->output_section->vma;

  if (coff_data (output_bfd)->pe)
     addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;

  fwrite (&addr, 1, sizeof (addr), (FILE *) info->base_file);
}

Here is the caller graph for this function:

bfd_boolean mcore_bfd_coff_final_link PARAMS ( (bfd *, struct bfd_link_info *)  )
static bfd_reloc_status_type mcore_coff_unsupported_reloc PARAMS ( (bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)  ) [static]
static reloc_howto_type* mcore_coff_reloc_type_lookup PARAMS ( (bfd *, bfd_reloc_code_real_type ) [static]
static void mcore_emit_base_file_entry PARAMS ( (struct bfd_link_info *, bfd *, asection *, bfd_vma ) [static]
static bfd_boolean in_reloc_p PARAMS ( (bfd *, reloc_howto_type *)  ) [static]

Variable Documentation

Definition at line 579 of file coff-mcore.c.

reloc_howto_type mcore_coff_howto_table[] [static]

Definition at line 71 of file coff-mcore.c.

Definition at line 579 of file coff-mcore.c.

Definition at line 579 of file coff-mcore.c.

Definition at line 579 of file coff-mcore.c.