Back to index

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

Go to the source code of this file.

Defines

#define F_LSYMS   F_LSYMS_TICOFF
#define coff_bfd_is_local_label_name   ticoff_bfd_is_local_label_name
#define RELOC_PROCESSING(RELENT, RELOC, SYMS, ABFD, SECT)   tic4x_reloc_processing (RELENT,RELOC,SYMS,ABFD,SECT)
#define BADMAG(x)   COFF2_BADMAG(x)
#define coff_rtype_to_howto   coff_tic4x_rtype_to_howto
#define HOWTO_SIZE   (sizeof(tic4x_howto_table) / sizeof(tic4x_howto_table[0]))
#define coff_bfd_reloc_type_lookup   tic4x_coff_reloc_type_lookup
#define coff_bfd_reloc_name_lookup   tic4x_coff_reloc_name_lookup

Functions

static bfd_boolean
ticoff_bfd_is_local_label_name 
PARAMS ((bfd *, const char *))
static bfd_reloc_status_type
tic4x_relocation 
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **))
static reloc_howto_type
*tic4x_coff_reloc_type_lookup 
PARAMS ((bfd *, bfd_reloc_code_real_type))
static void tic4x_lookup_howto PARAMS ((arelent *, struct internal_reloc *))
static reloc_howto_type
*coff_tic4x_rtype_to_howto 
PARAMS ((bfd *, asection *, struct internal_reloc *, struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *))
static void tic4x_reloc_processing PARAMS ((arelent *, struct internal_reloc *, asymbol **, bfd *, asection *))
static bfd_boolean ticoff_bfd_is_local_label_name (abfd, const char *name)
static bfd_reloc_status_type tic4x_relocation (abfd, arelent *reloc_entry, symbol, data, asection *input_section, bfd *output_bfd, error_message)
static reloc_howto_type * tic4x_coff_reloc_type_lookup (abfd, bfd_reloc_code_real_type code)
static reloc_howto_type * tic4x_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
static void tic4x_lookup_howto (arelent *internal, struct internal_reloc *dst)
static reloc_howto_type * coff_tic4x_rtype_to_howto (abfd, asection *sec, struct internal_reloc *rel, h, sym, bfd_vma *addendp)
static void tic4x_reloc_processing (arelent *relent, struct internal_reloc *reloc, asymbol **symbols, bfd *abfd, asection *section)
 CREATE_LITTLE_COFF_TARGET_VEC (tic4x_coff0_vec,"coff0-tic4x", HAS_LOAD_PAGE, 0, '_', NULL,(PTR)&ticoff0_swap_table)
 CREATE_BIGHDR_COFF_TARGET_VEC (tic4x_coff0_beh_vec,"coff0-beh-tic4x", HAS_LOAD_PAGE, 0, '_',&tic4x_coff0_vec,(PTR)&ticoff0_swap_table)
 CREATE_LITTLE_COFF_TARGET_VEC (tic4x_coff1_vec,"coff1-tic4x", HAS_LOAD_PAGE, 0, '_',&tic4x_coff0_beh_vec,(PTR)&ticoff1_swap_table)
 CREATE_BIGHDR_COFF_TARGET_VEC (tic4x_coff1_beh_vec,"coff1-beh-tic4x", HAS_LOAD_PAGE, 0, '_',&tic4x_coff1_vec,(PTR)&ticoff1_swap_table)
 CREATE_LITTLE_COFF_TARGET_VEC (tic4x_coff2_vec,"coff2-tic4x", HAS_LOAD_PAGE, 0, '_',&tic4x_coff1_beh_vec, COFF_SWAP_TABLE)
 CREATE_BIGHDR_COFF_TARGET_VEC (tic4x_coff2_beh_vec,"coff2-beh-tic4x", HAS_LOAD_PAGE, 0, '_',&tic4x_coff2_vec, COFF_SWAP_TABLE)

Variables

reloc_howto_type tic4x_howto_table []

Define Documentation

#define BADMAG (   x)    COFF2_BADMAG(x)

Definition at line 70 of file coff-tic4x.c.

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

Definition at line 121 of file coff-tic4x.c.

Definition at line 119 of file coff-tic4x.c.

Definition at line 73 of file coff-tic4x.c.

#define F_LSYMS   F_LSYMS_TICOFF

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

#define HOWTO_SIZE   (sizeof(tic4x_howto_table) / sizeof(tic4x_howto_table[0]))

Definition at line 116 of file coff-tic4x.c.

#define RELOC_PROCESSING (   RELENT,
  RELOC,
  SYMS,
  ABFD,
  SECT 
)    tic4x_reloc_processing (RELENT,RELOC,SYMS,ABFD,SECT)

Definition at line 63 of file coff-tic4x.c.


Function Documentation

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

Definition at line 197 of file coff-tic4x.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;

  tic4x_lookup_howto (&genrel, rel);

  return genrel.howto;
}

Here is the call graph for this function:

CREATE_BIGHDR_COFF_TARGET_VEC ( tic4x_coff0_beh_vec  ,
"coff0-beh-tic4x"  ,
HAS_LOAD_PAGE  ,
,
'_ ,
tic4x_coff0_vec,
(PTR)&  ticoff0_swap_table 
)
CREATE_BIGHDR_COFF_TARGET_VEC ( tic4x_coff1_beh_vec  ,
"coff1-beh-tic4x"  ,
HAS_LOAD_PAGE  ,
,
'_ ,
tic4x_coff1_vec,
(PTR)&  ticoff1_swap_table 
)
CREATE_BIGHDR_COFF_TARGET_VEC ( tic4x_coff2_beh_vec  ,
"coff2-beh-tic4x"  ,
HAS_LOAD_PAGE  ,
,
'_ ,
tic4x_coff2_vec,
COFF_SWAP_TABLE   
)
CREATE_LITTLE_COFF_TARGET_VEC ( tic4x_coff0_vec  ,
"coff0-tic4x"  ,
HAS_LOAD_PAGE  ,
,
'_ ,
NULL  ,
(PTR)&  ticoff0_swap_table 
)
CREATE_LITTLE_COFF_TARGET_VEC ( tic4x_coff1_vec  ,
"coff1-tic4x"  ,
HAS_LOAD_PAGE  ,
,
'_ ,
tic4x_coff0_beh_vec,
(PTR)&  ticoff1_swap_table 
)
CREATE_LITTLE_COFF_TARGET_VEC ( tic4x_coff2_vec  ,
"coff2-tic4x"  ,
HAS_LOAD_PAGE  ,
,
'_ ,
tic4x_coff1_beh_vec,
COFF_SWAP_TABLE   
)
static bfd_boolean ticoff_bfd_is_local_label_name PARAMS ( (bfd *, const char *)  ) [static]
static bfd_reloc_status_type tic4x_relocation PARAMS ( (bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)  ) [static]
static reloc_howto_type* tic4x_coff_reloc_type_lookup PARAMS ( (bfd *, bfd_reloc_code_real_type ) [static]
static void tic4x_lookup_howto PARAMS ( (arelent *, struct internal_reloc *)  ) [static]
static void tic4x_reloc_processing PARAMS ( (arelent *, struct internal_reloc *, asymbol **, bfd *, asection *)  ) [static]
static reloc_howto_type* tic4x_coff_reloc_name_lookup ( bfd *abfd  ATTRIBUTE_UNUSED,
const char *  r_name 
) [static]

Definition at line 156 of file coff-tic4x.c.

{
  unsigned int i;

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

  return NULL;
}

Here is the call graph for this function:

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

Definition at line 127 of file coff-tic4x.c.

{
  unsigned int type;
  unsigned int i;

  switch (code)
    {
    case BFD_RELOC_32:             type = R_RELLONG; break;
    case BFD_RELOC_24:             type = R_REL24; break;
    case BFD_RELOC_16:             type = R_RELWORD; break;
    case BFD_RELOC_24_PCREL:       type = R_PCR24; break;
    case BFD_RELOC_16_PCREL:       type = R_PCRWORD; break;
    case BFD_RELOC_HI16:    type = R_PARTMS8; break;
    case BFD_RELOC_LO16:    type = R_PARTLS16; break;
    default:
      return NULL;
    }

  for (i = 0; i < HOWTO_SIZE; i++)
    {
      if (tic4x_howto_table[i].type == type)
       return tic4x_howto_table + i;
    }
  return NULL;
}
static void tic4x_lookup_howto ( arelent internal,
struct internal_reloc dst 
) [static]

Definition at line 175 of file coff-tic4x.c.

{
  unsigned int i;
  int bank = (dst->r_symndx == -1) ? HOWTO_BANK : 0;

  for (i = 0; i < HOWTO_SIZE; i++)
    {
      if (tic4x_howto_table[i].type == dst->r_type)
       {
         internal->howto = tic4x_howto_table + i + bank;
         return;
       }
    }

  (*_bfd_error_handler) (_("Unrecognized reloc type 0x%x"),
                      (unsigned int) dst->r_type);
  abort();
}

Here is the caller graph for this function:

static void tic4x_reloc_processing ( arelent relent,
struct internal_reloc reloc,
asymbol **  symbols,
bfd abfd,
asection section 
) [static]

Definition at line 220 of file coff-tic4x.c.

{
  asymbol *ptr;

  relent->address = reloc->r_vaddr;

  if (reloc->r_symndx != -1)
    {
      if (reloc->r_symndx < 0 || reloc->r_symndx >= obj_conv_table_size (abfd))
        {
          (*_bfd_error_handler)
            (_("%s: warning: illegal symbol index %ld in relocs"),
             bfd_get_filename (abfd), reloc->r_symndx);
          relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
          ptr = NULL;
        }
      else
        {
          relent->sym_ptr_ptr = (symbols
                                 + obj_convert (abfd)[reloc->r_symndx]);
          ptr = *(relent->sym_ptr_ptr);
        }
    }
  else
    {
      relent->sym_ptr_ptr = section->symbol_ptr_ptr;
      ptr = *(relent->sym_ptr_ptr);
    }

  /* The symbols definitions that we have read in have been relocated
     as if their sections started at 0.  But the offsets refering to
     the symbols in the raw data have not been modified, so we have to
     have a negative addend to compensate.

     Note that symbols which used to be common must be left alone.  */

  /* Calculate any reloc addend by looking at the symbol.  */
  CALC_ADDEND (abfd, ptr, *reloc, relent);

  relent->address -= section->vma;
  /* !!     relent->section = (asection *) NULL;  */

  /* Fill in the relent->howto field from reloc->r_type.  */
  tic4x_lookup_howto (relent, reloc);
}

Here is the call graph for this function:

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

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

{
  if (output_bfd != (bfd *) NULL)
    {
      /* This is a partial relocation, and we want to apply the
        relocation to the reloc entry rather than the raw data.
        Modify the reloc inplace to reflect what we now know.  */
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }
  return bfd_reloc_continue;
}
static bfd_boolean ticoff_bfd_is_local_label_name ( abfd  ,
const char *  name 
) [static]

Definition at line 52 of file coff-tic4x.c.

{
  if (TICOFF_LOCAL_LABEL_P(name))
    return TRUE;
  return FALSE;
}

Variable Documentation

reloc_howto_type tic4x_howto_table[]
Initial value:
{
    HOWTO(R_RELWORD,  0,  2, 16, FALSE, 0, complain_overflow_signed,   tic4x_relocation, "RELWORD",   TRUE, 0x0000ffff, 0x0000ffff, FALSE),
    HOWTO(R_REL24,    0,  2, 24, FALSE, 0, complain_overflow_bitfield, tic4x_relocation, "REL24",     TRUE, 0x00ffffff, 0x00ffffff, FALSE),
    HOWTO(R_RELLONG,  0,  2, 32, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "RELLONG",   TRUE, 0xffffffff, 0xffffffff, FALSE),
    HOWTO(R_PCRWORD,  0,  2, 16, TRUE,  0, complain_overflow_signed,   tic4x_relocation, "PCRWORD",   TRUE, 0x0000ffff, 0x0000ffff, FALSE),
    HOWTO(R_PCR24,    0,  2, 24, TRUE,  0, complain_overflow_signed,   tic4x_relocation, "PCR24",     TRUE, 0x00ffffff, 0x00ffffff, FALSE),
    HOWTO(R_PARTLS16,        0,  2, 16, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "PARTLS16",  TRUE, 0x0000ffff, 0x0000ffff, FALSE),
    HOWTO(R_PARTMS8, 16,  2, 16, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "PARTMS8",   TRUE, 0x0000ffff, 0x0000ffff, FALSE),
    HOWTO(R_RELWORD,  0,  2, 16, FALSE, 0, complain_overflow_signed,   tic4x_relocation, "ARELWORD",  TRUE, 0x0000ffff, 0x0000ffff, FALSE),
    HOWTO(R_REL24,    0,  2, 24, FALSE, 0, complain_overflow_signed,   tic4x_relocation, "AREL24",    TRUE, 0x00ffffff, 0x00ffffff, FALSE),
    HOWTO(R_RELLONG,  0,  2, 32, FALSE, 0, complain_overflow_signed,   tic4x_relocation, "ARELLONG",  TRUE, 0xffffffff, 0xffffffff, FALSE),
    HOWTO(R_PCRWORD,  0,  2, 16, TRUE,  0, complain_overflow_signed,   tic4x_relocation, "APCRWORD",  TRUE, 0x0000ffff, 0x0000ffff, FALSE),
    HOWTO(R_PCR24,    0,  2, 24, TRUE,  0, complain_overflow_signed,   tic4x_relocation, "APCR24",    TRUE, 0x00ffffff, 0x00ffffff, FALSE),
    HOWTO(R_PARTLS16,        0,  2, 16, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "APARTLS16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),
    HOWTO(R_PARTMS8, 16,  2, 16, FALSE, 0, complain_overflow_dont,     tic4x_relocation, "APARTMS8",  TRUE, 0x0000ffff, 0x0000ffff, FALSE),
}

Definition at line 99 of file coff-tic4x.c.