Back to index

cell-binutils  2.17cvs20070401
Defines | Functions | Variables
coff-tic80.c File Reference
#include "bfd.h"
#include "bfdlink.h"
#include "sysdep.h"
#include "libbfd.h"
#include "coff/tic80.h"
#include "coff/internal.h"
#include "libcoff.h"
#include "coffcode.h"

Go to the source code of this file.

Defines

#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER   (2)
#define COFF_ALIGN_IN_SECTION_HEADER   1
#define COFF_ALIGN_IN_SFLAGS   1
#define GET_SCNHDR_FLAGS   H_GET_16
#define PUT_SCNHDR_FLAGS   H_PUT_16
#define RTYPE2HOWTO(cache_ptr, dst)   rtype2howto (cache_ptr, dst)
#define coff_rtype_to_howto   coff_tic80_rtype_to_howto
#define BADMAG(x)   TIC80BADMAG(x)
#define coff_relocate_section   coff_tic80_relocate_section
#define SWAP_OUT_RELOC_EXTRA(abfd, src, dst)
#define TIC80COFF   1 /* Customize coffcode.h */

Functions

static void rtype2howto PARAMS ((arelent *cache_ptr, struct internal_reloc *dst))
static bfd_reloc_status_type
ppbase_reloc 
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **))
static bfd_boolean
coff_tic80_relocate_section 
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, struct internal_reloc *, struct internal_syment *, asection **))
static reloc_howto_type
*coff_tic80_rtype_to_howto 
PARAMS ((bfd *, asection *, struct internal_reloc *, struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *))
static bfd_reloc_status_type ppbase_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, error_message)
static bfd_reloc_status_type glob15_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, error_message)
static bfd_reloc_status_type glob16_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, error_message)
static bfd_reloc_status_type local16_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd, error_message)
static void rtype2howto (arelent *cache_ptr, struct internal_reloc *dst)
static reloc_howto_type * coff_tic80_rtype_to_howto (abfd, asection *sec, struct internal_reloc *rel, h, sym, bfd_vma *addendp)
static bfd_boolean coff_tic80_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)

Variables

static reloc_howto_type tic80_howto_table []

Define Documentation

#define BADMAG (   x)    TIC80BADMAG(x)

Definition at line 489 of file coff-tic80.c.

Definition at line 44 of file coff-tic80.c.

#define COFF_ALIGN_IN_SFLAGS   1

Definition at line 45 of file coff-tic80.c.

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

Definition at line 492 of file coff-tic80.c.

Definition at line 464 of file coff-tic80.c.

#define GET_SCNHDR_FLAGS   H_GET_16

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

#define PUT_SCNHDR_FLAGS   H_PUT_16

Definition at line 48 of file coff-tic80.c.

#define RTYPE2HOWTO (   cache_ptr,
  dst 
)    rtype2howto (cache_ptr, dst)

Definition at line 463 of file coff-tic80.c.

#define SWAP_OUT_RELOC_EXTRA (   abfd,
  src,
  dst 
)
Value:
do \
    { \
      dst->r_reserved[0] = 0; \
      dst->r_reserved[1] = 0; \
    } \
  while (0)

Definition at line 726 of file coff-tic80.c.

#define TIC80COFF   1 /* Customize coffcode.h */

Definition at line 734 of file coff-tic80.c.


Function Documentation

static bfd_boolean coff_tic80_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 498 of file coff-tic80.c.

{
  struct internal_reloc *rel;
  struct internal_reloc *relend;

  rel = relocs;
  relend = rel + input_section->reloc_count;
  for (; rel < relend; rel++)
    {
      long symndx;
      struct coff_link_hash_entry *h;
      struct internal_syment *sym;
      bfd_vma addend;
      bfd_vma val;
      reloc_howto_type *howto;
      bfd_reloc_status_type rstat;
      bfd_vma addr;

      symndx = rel->r_symndx;

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

      /* COFF treats common symbols in one of two ways.  Either the
         size of the symbol is included in the section contents, or it
         is not.  We assume that the size is not included, and force
         the rtype_to_howto function to adjust the addend as needed.  */

      if (sym != NULL && sym->n_scnum != 0)
       addend = - sym->n_value;
      else
       addend = 0;

      howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
                                   sym, &addend);
      if (howto == NULL)
       return FALSE;

      val = 0;

      if (h == NULL)
       {
         asection *sec;

         if (symndx == -1)
           {
             sec = bfd_abs_section_ptr;
             val = 0;
           }
         else
           {
             sec = sections[symndx];
              val = (sec->output_section->vma
                   + sec->output_offset
                   + sym->n_value);
             if (! obj_pe (output_bfd))
              val -= sec->vma;
           }
       }
      else
       {
         if (h->root.type == bfd_link_hash_defined
             || h->root.type == bfd_link_hash_defweak)
           {
             asection *sec;

             sec = h->root.u.def.section;
             val = (h->root.u.def.value
                   + sec->output_section->vma
                   + sec->output_offset);
             }

         else if (! info->relocatable)
           {
             if (! ((*info->callbacks->undefined_symbol)
                   (info, h->root.root.string, input_bfd, input_section,
                    rel->r_vaddr - input_section->vma, TRUE)))
              return FALSE;
           }
       }

      addr = rel->r_vaddr - input_section->vma;

      /* FIXME: This code assumes little endian, but the PP can
         apparently be bi-endian.  I don't know if the bi-endianness
         applies to the instruction set or just to the data.  */
      switch (howto->type)
       {
       default:
       case R_ABS:
       case R_RELLONGX:
       case R_PPL15:
       case R_PPL15W:
       case R_PPL15H:
       case R_PPLN15:
       case R_PPLN15W:
       case R_PPLN15H:
         rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
                                       contents, addr, val, addend);
         break;

       case R_PP15:
       case R_PP15W:
       case R_PP15H:
       case R_PPN15:
       case R_PPN15W:
       case R_PPN15H:
         /* Offset the address so that we can use 4 byte relocations.  */
         rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
                                       contents + 2, addr, val, addend);
         break;

       case R_PP16B:
       case R_PPN16B:
         {
           /* The most significant bit is stored in bit 6.  */
           bfd_byte hold;

           hold = contents[addr + 4];
           contents[addr + 4] &=~ 0x20;
           contents[addr + 4] |= (contents[addr] >> 1) & 0x20;
           rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
                                         contents + 2, addr,
                                         val, addend);
           contents[addr] &=~ 0x40;
           contents[addr] |= (contents[addr + 4] << 1) & 0x40;
           contents[addr + 4] &=~ 0x20;
           contents[addr + 4] |= hold & 0x20;
           break;
         }

       case R_PPL16B:
       case R_PPLN16B:
         {
           /* The most significant bit is stored in bit 28.  */
           bfd_byte hold;

           hold = contents[addr + 1];
           contents[addr + 1] &=~ 0x80;
           contents[addr + 1] |= (contents[addr + 3] << 3) & 0x80;
           rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
                                         contents, addr,
                                         val, addend);
           contents[addr + 3] &= ~0x10;
           contents[addr + 3] |= (contents[addr + 1] >> 3) & 0x10;
           contents[addr + 1] &=~ 0x80;
           contents[addr + 1] |= hold & 0x80;
           break;
         }

       case R_PPBASE:
         /* Parameter RAM is from 0x1000000 to 0x1000800.  */
         contents[addr] &=~ 0x3;
         if (val >= 0x1000000 && val < 0x1000800)
           contents[addr] |= 0x3;
         else
           contents[addr] |= 0x2;
         rstat = bfd_reloc_ok;
         break;

       case R_PPLBASE:
         /* Parameter RAM is from 0x1000000 to 0x1000800.  */
         contents[addr + 2] &= ~0xc0;
         if (val >= 0x1000000 && val < 0x1000800)
           contents[addr + 2] |= 0xc0;
         else
           contents[addr + 2] |= 0x80;
         rstat = bfd_reloc_ok;
         break;
       }

      switch (rstat)
       {
       default:
         abort ();
       case bfd_reloc_ok:
         break;
       case bfd_reloc_outofrange:
         (*_bfd_error_handler)
           (_("%B: bad reloc address 0x%lx in section `%A'"),
            input_bfd, input_section, (unsigned long) rel->r_vaddr);
         return FALSE;
       case bfd_reloc_overflow:
         {
           const char *name;
           char buf[SYMNMLEN + 1];

           if (symndx == -1)
             name = "*ABS*";
           else if (h != NULL)
             name = NULL;
           else
             {
              name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
              if (name == NULL)
                return FALSE;
             }

           if (! ((*info->callbacks->reloc_overflow)
                 (info, (h ? &h->root : NULL), 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_tic80_rtype_to_howto ( abfd  ,
asection sec,
struct internal_reloc rel,
,
sym  ,
bfd_vma addendp 
) [static]

Definition at line 467 of file coff-tic80.c.

{
  arelent genrel;

  if (rel -> r_symndx == -1 && addendp != NULL)
    {
      /* This is a TI "internal relocation", which means that the relocation
        amount is the amount by which the current section is being relocated
        in the output section.  */
      *addendp = (sec -> output_section -> vma + sec -> output_offset) - sec -> vma;
    }
  RTYPE2HOWTO (&genrel, rel);
  return genrel.howto;
}
static bfd_reloc_status_type glob15_reloc ( abfd  ,
reloc_entry  ,
symbol_in  ,
data  ,
input_section  ,
output_bfd  ,
error_message   
) [static]

Definition at line 390 of file coff-tic80.c.

{
  /* FIXME.  */
  abort ();
}
static bfd_reloc_status_type glob16_reloc ( abfd  ,
reloc_entry  ,
symbol_in  ,
data  ,
input_section  ,
output_bfd  ,
error_message   
) [static]

Definition at line 407 of file coff-tic80.c.

{
  /* FIXME.  */
  abort ();
}
static bfd_reloc_status_type local16_reloc ( abfd  ,
reloc_entry  ,
symbol_in  ,
data  ,
input_section  ,
output_bfd  ,
error_message   
) [static]

Definition at line 424 of file coff-tic80.c.

{
  /* FIXME.  */
  abort ();
}
static void rtype2howto PARAMS ( (arelent *cache_ptr, struct internal_reloc *dst)  ) [static]
static bfd_reloc_status_type ppbase_reloc PARAMS ( (bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)  ) [static]
static bfd_reloc_status_type ppbase_reloc ( abfd  ,
reloc_entry  ,
symbol_in  ,
data  ,
input_section  ,
output_bfd  ,
error_message   
) [static]

Definition at line 373 of file coff-tic80.c.

{
  /* FIXME.  */
  abort ();
}
static void rtype2howto ( arelent cache_ptr,
struct internal_reloc dst 
) [static]

Definition at line 443 of file coff-tic80.c.

{
  unsigned int i;

  for (i = 0; i < sizeof tic80_howto_table / sizeof tic80_howto_table[0]; i++)
    {
      if (tic80_howto_table[i].type == dst->r_type)
       {
         cache_ptr->howto = tic80_howto_table + i;
         return;
       }
    }

  (*_bfd_error_handler) (_("Unrecognized reloc type 0x%x"),
                      (unsigned int) dst->r_type);
  cache_ptr->howto = tic80_howto_table + 0;
}

Variable Documentation

reloc_howto_type tic80_howto_table[] [static]

Definition at line 68 of file coff-tic80.c.