Back to index

cell-binutils  2.17cvs20070401
Defines | Functions
i386lynx.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "libaout.h"
#include "aout/aout64.h"
#include "aout-target.h"

Go to the source code of this file.

Defines

#define N_SHARED_LIB(x)   0
#define TEXT_START_ADDR   0
#define TARGET_PAGE_SIZE   4096
#define SEGMENT_SIZE   TARGET_PAGE_SIZE
#define DEFAULT_ARCH   bfd_arch_i386
#define MY(OP)   CONCAT2 (i386lynx_aout_,OP)
#define TARGETNAME   "a.out-i386-lynx"
#define WRITE_HEADERS(abfd, execp)
#define KEEPIT   udata.i
#define MOVE_ADDRESS(ad)
#define MY_canonicalize_reloc   NAME(lynx,canonicalize_reloc)

Functions

void NAME (void NAME(lynx, swap_std_reloc_out)
void NAME (lynx, swap_ext_reloc_out)
void NAME (lynx, swap_ext_reloc_in)
void NAME (lynx, swap_std_reloc_in)
bfd_boolean NAME (lynx, slurp_reloc_table)
bfd_boolean NAME (lynx, squirt_out_relocs)
long NAME (lynx, canonicalize_reloc)

Define Documentation

Definition at line 26 of file i386lynx.c.

#define KEEPIT   udata.i
#define MOVE_ADDRESS (   ad)

Definition at line 308 of file i386lynx.c.

#define MY (   OP)    CONCAT2 (i386lynx_aout_,OP)

Definition at line 31 of file i386lynx.c.

Definition at line 579 of file i386lynx.c.

#define N_SHARED_LIB (   x)    0

Definition at line 21 of file i386lynx.c.

Definition at line 25 of file i386lynx.c.

#define TARGET_PAGE_SIZE   4096

Definition at line 24 of file i386lynx.c.

#define TARGETNAME   "a.out-i386-lynx"

Definition at line 32 of file i386lynx.c.

#define TEXT_START_ADDR   0

Definition at line 23 of file i386lynx.c.

#define WRITE_HEADERS (   abfd,
  execp 
)

Definition at line 39 of file i386lynx.c.


Function Documentation

void NAME ( void NAME lynx,
swap_std_reloc_out   
)

Definition at line 88 of file i386lynx.c.

{
  int r_index;
  asymbol *sym = *(g->sym_ptr_ptr);
  int r_extern;
  unsigned int r_length;
  int r_pcrel;
  int r_baserel, r_jmptable, r_relative;
  unsigned int r_addend;
  asection *output_section = sym->section->output_section;

  PUT_WORD (abfd, g->address, natptr->r_address);

  r_length = g->howto->size;       /* Size as a power of two */
  r_pcrel = (int) g->howto->pc_relative;  /* Relative to PC? */
  /* r_baserel, r_jmptable, r_relative???  FIXME-soon */
  r_baserel = 0;
  r_jmptable = 0;
  r_relative = 0;

  r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;

  /* name was clobbered by aout_write_syms to be symbol index */

  /* If this relocation is relative to a symbol then set the
     r_index to the symbols index, and the r_extern bit.

     Absolute symbols can come in in two ways, either as an offset
     from the abs section, or as a symbol which has an abs value.
     check for that here
  */


  if (bfd_is_com_section (output_section)
      || bfd_is_abs_section (output_section)
      || bfd_is_und_section (output_section))
    {
      if (bfd_abs_section_ptr->symbol == sym)
       {
         /* Whoops, looked like an abs symbol, but is really an offset
            from the abs section */
         r_index = 0;
         r_extern = 0;
       }
      else
       {
         /* Fill in symbol */
         r_extern = 1;
         r_index = (*g->sym_ptr_ptr)->KEEPIT;
       }
    }
  else
    {
      /* Just an ordinary section */
      r_extern = 0;
      r_index = output_section->target_index;
    }

  /* now the fun stuff */
  if (bfd_header_big_endian (abfd))
    {
      natptr->r_index[0] = r_index >> 16;
      natptr->r_index[1] = r_index >> 8;
      natptr->r_index[2] = r_index;
      natptr->r_type[0] =
       (r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
       | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
       | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
       | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
       | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
       | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG);
    }
  else
    {
      natptr->r_index[2] = r_index >> 16;
      natptr->r_index[1] = r_index >> 8;
      natptr->r_index[0] = r_index;
      natptr->r_type[0] =
       (r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
       | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
       | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
       | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
       | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
       | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE);
    }
}
void NAME ( lynx  ,
swap_ext_reloc_out   
)

Definition at line 224 of file i386lynx.c.

{
  int r_index;
  int r_extern;
  unsigned int r_type;
  unsigned int r_addend;
  asymbol *sym = *(g->sym_ptr_ptr);
  asection *output_section = sym->section->output_section;

  PUT_WORD (abfd, g->address, natptr->r_address);

  r_type = (unsigned int) g->howto->type;

  r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;


  /* If this relocation is relative to a symbol then set the
     r_index to the symbols index, and the r_extern bit.

     Absolute symbols can come in in two ways, either as an offset
     from the abs section, or as a symbol which has an abs value.
     check for that here
     */

  if (bfd_is_com_section (output_section)
      || bfd_is_abs_section (output_section)
      || bfd_is_und_section (output_section))
    {
      if (bfd_abs_section_ptr->symbol == sym)
       {
         /* Whoops, looked like an abs symbol, but is really an offset
        from the abs section */
         r_index = 0;
         r_extern = 0;
       }
      else
       {
         r_extern = 1;
         r_index = (*g->sym_ptr_ptr)->KEEPIT;
       }
    }
  else
    {
      /* Just an ordinary section */
      r_extern = 0;
      r_index = output_section->target_index;
    }


  /* now the fun stuff */
  if (bfd_header_big_endian (abfd))
    {
      natptr->r_index[0] = r_index >> 16;
      natptr->r_index[1] = r_index >> 8;
      natptr->r_index[2] = r_index;
      natptr->r_type[0] =
       (r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
       | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG);
    }
  else
    {
      natptr->r_index[2] = r_index >> 16;
      natptr->r_index[1] = r_index >> 8;
      natptr->r_index[0] = r_index;
      natptr->r_type[0] =
       (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
       | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
    }

  PUT_WORD (abfd, r_addend, natptr->r_addend);
}
void NAME ( lynx  ,
swap_ext_reloc_in   
)

Definition at line 341 of file i386lynx.c.

{
  int r_index;
  int r_extern;
  unsigned int r_type;
  struct aoutdata *su = &(abfd->tdata.aout_data->a);

  cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));

  r_index = bytes->r_index[1];
  r_extern = (0 != (bytes->r_index[0] & RELOC_EXT_BITS_EXTERN_BIG));
  r_type = (bytes->r_index[0] & RELOC_EXT_BITS_TYPE_BIG)
    >> RELOC_EXT_BITS_TYPE_SH_BIG;

  cache_ptr->howto = aout_32_ext_howto_table + r_type;
  MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
void NAME ( lynx  ,
swap_std_reloc_in   
)

Definition at line 365 of file i386lynx.c.

{
  int r_index;
  int r_extern;
  unsigned int r_length;
  int r_pcrel;
  int r_baserel, r_jmptable, r_relative;
  struct aoutdata *su = &(abfd->tdata.aout_data->a);

  cache_ptr->address = H_GET_32 (abfd, bytes->r_address);

  r_index = bytes->r_index[1];
  r_extern = (0 != (bytes->r_index[0] & RELOC_STD_BITS_EXTERN_BIG));
  r_pcrel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_PCREL_BIG));
  r_baserel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_BASEREL_BIG));
  r_jmptable = (0 != (bytes->r_index[0] & RELOC_STD_BITS_JMPTABLE_BIG));
  r_relative = (0 != (bytes->r_index[0] & RELOC_STD_BITS_RELATIVE_BIG));
  r_length = (bytes->r_index[0] & RELOC_STD_BITS_LENGTH_BIG)
    >> RELOC_STD_BITS_LENGTH_SH_BIG;

  cache_ptr->howto = aout_32_std_howto_table + r_length + 4 * r_pcrel;
  /* FIXME-soon:  Roll baserel, jmptable, relative bits into howto setting */

  MOVE_ADDRESS (0);
bfd_boolean NAME ( lynx  ,
slurp_reloc_table   
)

Definition at line 399 of file i386lynx.c.

{
  bfd_size_type count;
  bfd_size_type reloc_size;
  PTR relocs;
  arelent *reloc_cache;
  size_t each_size;

  if (asect->relocation)
    return TRUE;

  if (asect->flags & SEC_CONSTRUCTOR)
    return TRUE;

  if (asect == obj_datasec (abfd))
    {
      reloc_size = exec_hdr (abfd)->a_drsize;
      goto doit;
    }

  if (asect == obj_textsec (abfd))
    {
      reloc_size = exec_hdr (abfd)->a_trsize;
      goto doit;
    }

  bfd_set_error (bfd_error_invalid_operation);
  return FALSE;

doit:
  if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
    return FALSE;
  each_size = obj_reloc_entry_size (abfd);

  count = reloc_size / each_size;


  reloc_cache = (arelent *) bfd_zmalloc (count * sizeof (arelent));
  if (!reloc_cache && count != 0)
    return FALSE;

  relocs = (PTR) bfd_alloc (abfd, reloc_size);
  if (!relocs && reloc_size != 0)
    {
      free (reloc_cache);
      return FALSE;
    }

  if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
    {
      bfd_release (abfd, relocs);
      free (reloc_cache);
      return FALSE;
    }

  if (each_size == RELOC_EXT_SIZE)
    {
      register struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
      unsigned int counter = 0;
      arelent *cache_ptr = reloc_cache;

      for (; counter < count; counter++, rptr++, cache_ptr++)
       {
         NAME(lynx,swap_ext_reloc_in) (abfd, rptr, cache_ptr, symbols,
                                   (bfd_size_type) bfd_get_symcount (abfd));
       }
    }
  else
    {
      register struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
      unsigned int counter = 0;
      arelent *cache_ptr = reloc_cache;

      for (; counter < count; counter++, rptr++, cache_ptr++)
       {
         NAME(lynx,swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols,
                                   (bfd_size_type) bfd_get_symcount (abfd));
       }

    }

  bfd_release (abfd, relocs);
  asect->relocation = reloc_cache;
  asect->reloc_count = count;
  return TRUE;

Here is the call graph for this function:

bfd_boolean NAME ( lynx  ,
squirt_out_relocs   
)

Definition at line 494 of file i386lynx.c.

{
  arelent **generic;
  unsigned char *native, *natptr;
  size_t each_size;

  unsigned int count = section->reloc_count;
  bfd_size_type natsize;

  if (count == 0)
    return TRUE;

  each_size = obj_reloc_entry_size (abfd);
  natsize = count;
  natsize *= each_size;
  native = (unsigned char *) bfd_zalloc (abfd, natsize);
  if (!native)
    return FALSE;

  generic = section->orelocation;

  if (each_size == RELOC_EXT_SIZE)
    {
      for (natptr = native;
          count != 0;
          --count, natptr += each_size, ++generic)
       NAME(lynx,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *) natptr);
    }
  else
    {
      for (natptr = native;
          count != 0;
          --count, natptr += each_size, ++generic)
       NAME(lynx,swap_std_reloc_out) (abfd, *generic, (struct reloc_std_external *) natptr);
    }

  if (bfd_bwrite ((PTR) native, natsize, abfd) != natsize)
    {
      bfd_release (abfd, native);
      return FALSE;
    }
  bfd_release (abfd, native);

  return TRUE;

Here is the call graph for this function:

long NAME ( lynx  ,
canonicalize_reloc   
)

Definition at line 544 of file i386lynx.c.

{
  arelent *tblptr = section->relocation;
  unsigned int count;

  if (!(tblptr || NAME(lynx,slurp_reloc_table) (abfd, section, symbols)))
    return -1;

  if (section->flags & SEC_CONSTRUCTOR)
    {
      arelent_chain *chain = section->constructor_chain;
      for (count = 0; count < section->reloc_count; count++)
       {
         *relptr++ = &chain->relent;
         chain = chain->next;
       }
    }
  else
    {
      tblptr = section->relocation;

      for (count = 0; count++ < section->reloc_count;)
       {
         *relptr++ = tblptr++;
       }
    }
  *relptr = 0;

  return section->reloc_count;

Here is the call graph for this function: