Back to index

cell-binutils  2.17cvs20070401
Defines | Functions | Variables
riscix.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 SHLIBLEN   60
#define MF_IMPURE   00200
#define MF_SQUEEZED   01000
#define MF_USES_SL   02000
#define MF_IS_SL   04000
#define IMAGIC   (MF_IMPURE | ZMAGIC)
#define SPOMAGIC   (MF_USES_SL | OMAGIC)
#define SLOMAGIC   (MF_IS_SL | OMAGIC)
#define QMAGIC   (MF_SQUEEZED | ZMAGIC)
#define SPZMAGIC   (MF_USES_SL | ZMAGIC)
#define SPQMAGIC   (MF_USES_SL | QMAGIC)
#define SLZMAGIC   (MF_IS_SL | ZMAGIC)
#define SLPZMAGIC   (MF_USES_SL | SLZMAGIC)
#define N_SHARED_LIB(x)   ((x).a_info & MF_USES_SL)
#define N_TXTOFF(x)
#define N_TXTADDR(x)
#define N_SYMOFF(x)   (N_TXTOFF (x) + (x).a_text + (x).a_data + (x).a_trsize + (x).a_drsize)
#define N_STROFF(x)   (N_SYMOFF (x) + (x).a_syms)
#define TEXT_START_ADDR   32768
#define TARGET_PAGE_SIZE   32768
#define SEGMENT_SIZE   TARGET_PAGE_SIZE
#define DEFAULT_ARCH   bfd_arch_arm
#define MY(OP)   CONCAT2 (riscix_,OP)
#define TARGETNAME   "a.out-riscix"
#define N_BADMAG(x)
#define N_MAGIC(x)   ((x).a_info & ~07200)
#define WRITE_HEADERS(abfd, execp)
#define RISCIX_TABLE_SIZE   (sizeof (riscix_std_reloc_howto) / sizeof (reloc_howto_type))
#define ASTD(i, j)   case i: return &riscix_std_reloc_howto[j]
#define MY_bfd_link_hash_table_create   _bfd_generic_link_hash_table_create
#define MY_bfd_link_add_symbols   _bfd_generic_link_add_symbols
#define MY_final_link_callback   should_not_be_used
#define MY_bfd_final_link   _bfd_generic_final_link
#define MY_bfd_reloc_type_lookup   riscix_reloc_type_lookup
#define MY_bfd_reloc_name_lookup   riscix_reloc_name_lookup
#define MY_canonicalize_reloc   riscix_canonicalize_reloc
#define MY_object_p   riscix_object_p

Functions

static bfd_reloc_status_type riscix_fix_pcrel_26_done (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry ATTRIBUTE_UNUSED, asymbol *symbol ATTRIBUTE_UNUSED, void *data ATTRIBUTE_UNUSED, asection *input_section ATTRIBUTE_UNUSED, bfd *output_bfd ATTRIBUTE_UNUSED, char **error_message ATTRIBUTE_UNUSED)
static bfd_reloc_status_type riscix_fix_pcrel_26 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **)
static const bfd_targetriscix_callback (bfd *)
static bfd_reloc_status_type riscix_fix_pcrel_26 (bfd *abfd, arelent *reloc_entry, asymbol *symbol, void *data, asection *input_section, bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
static reloc_howto_type * riscix_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
static reloc_howto_type * riscix_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
static void riscix_swap_std_reloc_out (bfd *abfd, arelent *g, struct reloc_std_external *natptr)
static bfd_boolean riscix_squirt_out_relocs (bfd *abfd, asection *section)
static long MY() canonicalize_reloc (bfd *abfd, sec_ptr section, arelent **relptr, asymbol **symbols)
static const bfd_targetriscix_some_aout_object_p (bfd *abfd, struct internal_exec *execp, const bfd_target *(*callback_to_real_object_p)(bfd *))
static const bfd_target *MY() object_p (bfd *abfd)

Variables

static reloc_howto_type riscix_std_reloc_howto []

Define Documentation

#define ASTD (   i,
  j 
)    case i: return &riscix_std_reloc_howto[j]
#define DEFAULT_ARCH   bfd_arch_arm

Definition at line 91 of file riscix.c.

#define IMAGIC   (MF_IMPURE | ZMAGIC)

Definition at line 37 of file riscix.c.

#define MF_IMPURE   00200

Definition at line 29 of file riscix.c.

#define MF_IS_SL   04000

Definition at line 32 of file riscix.c.

#define MF_SQUEEZED   01000

Definition at line 30 of file riscix.c.

#define MF_USES_SL   02000

Definition at line 31 of file riscix.c.

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

Definition at line 96 of file riscix.c.

Definition at line 293 of file riscix.c.

Definition at line 291 of file riscix.c.

Definition at line 290 of file riscix.c.

Definition at line 296 of file riscix.c.

Definition at line 295 of file riscix.c.

#define MY_canonicalize_reloc   riscix_canonicalize_reloc

Definition at line 297 of file riscix.c.

#define MY_final_link_callback   should_not_be_used

Definition at line 292 of file riscix.c.

#define MY_object_p   riscix_object_p

Definition at line 298 of file riscix.c.

#define N_BADMAG (   x)
Value:
((((x).a_info & ~007200) != ZMAGIC) \
                  && (((x).a_info & ~006000) != OMAGIC) \
                  && ((x).a_info != NMAGIC))

Definition at line 98 of file riscix.c.

#define N_MAGIC (   x)    ((x).a_info & ~07200)

Definition at line 101 of file riscix.c.

#define N_SHARED_LIB (   x)    ((x).a_info & MF_USES_SL)

Definition at line 65 of file riscix.c.

#define N_STROFF (   x)    (N_SYMOFF (x) + (x).a_syms)

Definition at line 86 of file riscix.c.

#define N_SYMOFF (   x)    (N_TXTOFF (x) + (x).a_text + (x).a_data + (x).a_trsize + (x).a_drsize)

Definition at line 83 of file riscix.c.

#define N_TXTADDR (   x)
Value:
(N_MAGIC(x) != ZMAGIC                                                      \
   ? (bfd_vma) 0 /* object file or NMAGIC */                               \
   /* Programs with shared libs are loaded at the first page after all the   \
      text segments of the shared library programs.  Without looking this    \
      up we can't know exactly what the address will be.  A reasonable guess \
      is that a_entry will be in the first page of the executable.  */            \
   : (N_SHARED_LIB(x)                                                      \
      ? ((x).a_entry & ~(bfd_vma) (TARGET_PAGE_SIZE - 1))                  \
      : (bfd_vma) TEXT_START_ADDR))

Definition at line 75 of file riscix.c.

#define N_TXTOFF (   x)
Value:
((x).a_info == OMAGIC              \
  ? 32                      \
  : (N_MAGIC(x) == ZMAGIC   \
     ? TARGET_PAGE_SIZE            \
     : 999))

Definition at line 68 of file riscix.c.

#define QMAGIC   (MF_SQUEEZED | ZMAGIC)

Definition at line 51 of file riscix.c.

#define RISCIX_TABLE_SIZE   (sizeof (riscix_std_reloc_howto) / sizeof (reloc_howto_type))

Definition at line 187 of file riscix.c.

Definition at line 90 of file riscix.c.

#define SHLIBLEN   60

Definition at line 27 of file riscix.c.

#define SLOMAGIC   (MF_IS_SL | OMAGIC)

Definition at line 46 of file riscix.c.

#define SLPZMAGIC   (MF_USES_SL | SLZMAGIC)

Definition at line 63 of file riscix.c.

#define SLZMAGIC   (MF_IS_SL | ZMAGIC)

Definition at line 60 of file riscix.c.

#define SPOMAGIC   (MF_USES_SL | OMAGIC)

Definition at line 41 of file riscix.c.

#define SPQMAGIC   (MF_USES_SL | QMAGIC)

Definition at line 57 of file riscix.c.

#define SPZMAGIC   (MF_USES_SL | ZMAGIC)

Definition at line 54 of file riscix.c.

#define TARGET_PAGE_SIZE   32768

Definition at line 89 of file riscix.c.

#define TARGETNAME   "a.out-riscix"

Definition at line 97 of file riscix.c.

#define TEXT_START_ADDR   32768

Definition at line 88 of file riscix.c.

#define WRITE_HEADERS (   abfd,
  execp 
)

Definition at line 107 of file riscix.c.


Function Documentation

static long MY() canonicalize_reloc ( bfd abfd,
sec_ptr  section,
arelent **  relptr,
asymbol **  symbols 
) [static]

Definition at line 429 of file riscix.c.

{
  arelent *tblptr = section->relocation;
  unsigned int count, c;
  extern reloc_howto_type NAME (aout, std_howto_table)[];

  /* If we have already read in the relocation table, return the values.  */
  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;
       }
      *relptr = 0;
      return section->reloc_count;
    }

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

  if (!NAME (aout, slurp_reloc_table) (abfd, section, symbols))
    return -1;
  tblptr = section->relocation;

  /* Fix up howto entries.  */
  for (count = 0; count++ < section->reloc_count;)
    {
      c = tblptr->howto - NAME(aout,std_howto_table);
      BFD_ASSERT (c < RISCIX_TABLE_SIZE);
      tblptr->howto = &riscix_std_reloc_howto[c];

      *relptr++ = tblptr++;
    }

Here is the call graph for this function:

static const bfd_target* MY() object_p ( bfd abfd) [static]

Definition at line 620 of file riscix.c.

{
  struct external_exec exec_bytes;      /* Raw exec header from file.  */
  struct internal_exec exec;            /* Cleaned-up exec header.  */
  const bfd_target *target;

  if (bfd_bread ((void *) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
      != EXEC_BYTES_SIZE)
    {
      if (bfd_get_error () != bfd_error_system_call)
       bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }

  exec.a_info = H_GET_32 (abfd, exec_bytes.e_info);

  if (N_BADMAG (exec))
    return NULL;

#ifdef MACHTYPE_OK
  if (!(MACHTYPE_OK (N_MACHTYPE (exec))))
    return NULL;
#endif

  NAME (aout, swap_exec_header_in) (abfd, & exec_bytes, & exec);

  target = riscix_some_aout_object_p (abfd, & exec, MY (callback));
static const bfd_target* riscix_callback ( bfd ) [static]
static bfd_reloc_status_type riscix_fix_pcrel_26 ( bfd ,
arelent ,
asymbol ,
void *  ,
asection ,
bfd ,
char **   
) [static]
static bfd_reloc_status_type riscix_fix_pcrel_26 ( bfd abfd,
arelent reloc_entry,
asymbol symbol,
void *  data,
asection input_section,
bfd output_bfd,
char **error_message  ATTRIBUTE_UNUSED 
) [static]

Definition at line 191 of file riscix.c.

{
  bfd_vma relocation;
  bfd_size_type addr = reloc_entry->address;
  long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
  bfd_reloc_status_type flag = bfd_reloc_ok;

  /* If this is an undefined symbol, return error.  */
  if (symbol->section == &bfd_und_section
      && (symbol->flags & BSF_WEAK) == 0)
    return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;

  /* If the sections are different, and we are doing a partial relocation,
     just ignore it for now.  */
  if (symbol->section->name != input_section->name
      && output_bfd != NULL)
    return bfd_reloc_continue;

  relocation = (target & 0x00ffffff) << 2;
  relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend.  */
  relocation += symbol->value;
  relocation += symbol->section->output_section->vma;
  relocation += symbol->section->output_offset;
  relocation += reloc_entry->addend;
  relocation -= input_section->output_section->vma;
  relocation -= input_section->output_offset;
  relocation -= addr;
  if (relocation & 3)
    return bfd_reloc_overflow;

  /* Check for overflow.  */
  if (relocation & 0x02000000)
    {
      if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
       flag = bfd_reloc_overflow;
    }
  else if (relocation & ~ (bfd_vma) 0x03ffffff)
    flag = bfd_reloc_overflow;

  target &= ~0x00ffffff;
  target |= (relocation >> 2) & 0x00ffffff;
  bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);

  /* Now the ARM magic... Change the reloc type so that it is marked as done.
     Strictly this is only necessary if we are doing a partial relocation.  */
  reloc_entry->howto = &riscix_std_reloc_howto[7];
static bfd_reloc_status_type riscix_fix_pcrel_26_done ( bfd *abfd  ATTRIBUTE_UNUSED,
arelent *reloc_entry  ATTRIBUTE_UNUSED,
asymbol *symbol  ATTRIBUTE_UNUSED,
void *data  ATTRIBUTE_UNUSED,
asection *input_section  ATTRIBUTE_UNUSED,
bfd *output_bfd  ATTRIBUTE_UNUSED,
char **error_message  ATTRIBUTE_UNUSED 
) [static]

Definition at line 156 of file riscix.c.

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

Definition at line 275 of file riscix.c.

{
  unsigned int i;

  for (i = 0;
       i < sizeof (riscix_std_reloc_howto) / sizeof (riscix_std_reloc_howto[0]);
       i++)
    if (riscix_std_reloc_howto[i].name != NULL
       && strcasecmp (riscix_std_reloc_howto[i].name, r_name) == 0)
      return &riscix_std_reloc_howto[i];
static reloc_howto_type* riscix_reloc_type_lookup ( bfd abfd,
bfd_reloc_code_real_type  code 
) [static]

Definition at line 248 of file riscix.c.

{
#define ASTD(i,j)       case i: return &riscix_std_reloc_howto[j]
  if (code == BFD_RELOC_CTOR)
    switch (bfd_get_arch_info (abfd)->bits_per_address)
      {
      case 32:
        code = BFD_RELOC_32;
        break;
      default:
       return NULL;
      }

  switch (code)
    {
      ASTD (BFD_RELOC_16, 1);
      ASTD (BFD_RELOC_32, 2);
      ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
      ASTD (BFD_RELOC_8_PCREL, 4);
      ASTD (BFD_RELOC_16_PCREL, 5);
      ASTD (BFD_RELOC_32_PCREL, 6);
    default:
static const bfd_target* riscix_some_aout_object_p ( bfd abfd,
struct internal_exec execp,
const bfd_target *(*)(bfd *)  callback_to_real_object_p 
) [static]

Definition at line 481 of file riscix.c.

{
  struct aout_data_struct *rawptr, *oldrawptr;
  const bfd_target *result;
  bfd_size_type amt = sizeof (struct aout_data_struct);

  rawptr = bfd_zalloc (abfd, amt);

  if (rawptr == NULL)
    return NULL;

  oldrawptr = abfd->tdata.aout_data;
  abfd->tdata.aout_data = rawptr;

  /* Copy the contents of the old tdata struct.
     In particular, we want the subformat, since for hpux it was set in
     hp300hpux.c:swap_exec_header_in and will be used in
     hp300hpux.c:callback.  */
  if (oldrawptr != NULL)
    *abfd->tdata.aout_data = *oldrawptr;

  abfd->tdata.aout_data->a.hdr = &rawptr->e;
  /* Copy in the internal_exec struct.  */
  *(abfd->tdata.aout_data->a.hdr) = *execp;
  execp = abfd->tdata.aout_data->a.hdr;

  /* Set the file flags.  */
  abfd->flags = BFD_NO_FLAGS;
  if (execp->a_drsize || execp->a_trsize)
    abfd->flags |= HAS_RELOC;
  /* Setting of EXEC_P has been deferred to the bottom of this function.  */
  if (execp->a_syms)
    abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
  if (N_DYNAMIC(*execp))
    abfd->flags |= DYNAMIC;

 /* Squeezed files aren't supported (yet)!  */
  if ((execp->a_info & MF_SQUEEZED) != 0)
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
  else if ((execp->a_info & MF_IS_SL) != 0)
    {
      /* Nor are shared libraries.  */
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
  else if (N_MAGIC (*execp) == ZMAGIC)
    {
      abfd->flags |= D_PAGED | WP_TEXT;
      adata (abfd).magic = z_magic;
    }
  else if (N_MAGIC (*execp) == NMAGIC)
    {
      abfd->flags |= WP_TEXT;
      adata (abfd).magic = n_magic;
    }
  else if (N_MAGIC (*execp) == OMAGIC)
    adata (abfd).magic = o_magic;
  else
    /* Should have been checked with N_BADMAG before this routine
       was called.  */
    abort ();

  bfd_get_start_address (abfd) = execp->a_entry;

  obj_aout_symbols (abfd) = NULL;
  bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);

  /* The default relocation entry size is that of traditional V7 Unix.  */
  obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;

  /* The default symbol entry size is that of traditional Unix.  */
  obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;

  obj_aout_external_syms (abfd) = NULL;
  obj_aout_external_strings (abfd) = NULL;
  obj_aout_sym_hashes (abfd) = NULL;

  if (! NAME (aout, make_sections) (abfd))
    return NULL;

  obj_datasec (abfd)->size = execp->a_data;
  obj_bsssec (abfd)->size = execp->a_bss;

  obj_textsec (abfd)->flags =
    (execp->a_trsize != 0
     ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
     : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
  obj_datasec (abfd)->flags =
    (execp->a_drsize != 0
     ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
     : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
  obj_bsssec (abfd)->flags = SEC_ALLOC;

  result = (*callback_to_real_object_p) (abfd);

#if defined(MACH) || defined(STAT_FOR_EXEC)
  /* The original heuristic doesn't work in some important cases. The
     a.out file has no information about the text start address. For
     files (like kernels) linked to non-standard addresses (ld -Ttext
     nnn) the entry point may not be between the default text start
     (obj_textsec(abfd)->vma) and (obj_textsec(abfd)->vma) + text size
     This is not just a mach issue. Many kernels are loaded at non
     standard addresses.  */
  {
    struct stat stat_buf;

    if (abfd->iostream != NULL
       && (abfd->flags & BFD_IN_MEMORY) == 0
        && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
        && ((stat_buf.st_mode & 0111) != 0))
      abfd->flags |= EXEC_P;
  }
#else /* ! MACH */
  /* Now that the segment addresses have been worked out, take a better
     guess at whether the file is executable.  If the entry point
     is within the text segment, assume it is.  (This makes files
     executable even if their entry point address is 0, as long as
     their text starts at zero.)

     At some point we should probably break down and stat the file and
     declare it executable if (one of) its 'x' bits are on...  */
  if ((execp->a_entry >= obj_textsec(abfd)->vma) &&
      (execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->size))
    abfd->flags |= EXEC_P;
#endif /* MACH */
  if (result == NULL)
    {
      free (rawptr);
      abfd->tdata.aout_data = oldrawptr;

Here is the call graph for this function:

static bfd_boolean riscix_squirt_out_relocs ( bfd abfd,
asection section 
) [static]

Definition at line 389 of file riscix.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 = each_size;
  natsize *= count;
  native = bfd_zalloc (abfd, natsize);
  if (!native)
    return FALSE;

  generic = section->orelocation;

  for (natptr = native;
       count != 0;
       --count, natptr += each_size, ++generic)
    riscix_swap_std_reloc_out (abfd, *generic,
                            (struct reloc_std_external *) natptr);

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

static void riscix_swap_std_reloc_out ( bfd abfd,
arelent g,
struct reloc_std_external natptr 
) [static]

Definition at line 301 of file riscix.c.

{
  int r_index;
  asymbol *sym = *(g->sym_ptr_ptr);
  int r_extern;
  int r_length;
  int r_pcrel;
  int r_neg = 0;     /* Negative relocs use the BASEREL bit.  */
  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.  */
  if (r_length < 0)
    {
      r_length = -r_length;
      r_neg = 1;
    }

  r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC?  */

  /* For RISC iX, in pc-relative relocs the r_pcrel bit means that the
     relocation has been done already (Only for the 26-bit one I think)?  */
  if (r_length == 3)
    r_pcrel = r_pcrel ? 0 : 1;

  /* 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)
      || output_section == & bfd_abs_section
      || output_section == & bfd_und_section)
    {
      if (bfd_abs_section.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)->udata.i;
       }
    }
  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_neg    ?   RELOC_STD_BITS_BASEREL_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_neg    ?   RELOC_STD_BITS_BASEREL_LITTLE: 0)

Variable Documentation

reloc_howto_type riscix_std_reloc_howto[] [static]
Initial value:
{
  
  HOWTO( 0,              0,  0,   8,  FALSE, 0, complain_overflow_bitfield,0,"8",         TRUE, 0x000000ff,0x000000ff, FALSE),
  HOWTO( 1,              0,  1,   16, FALSE, 0, complain_overflow_bitfield,0,"16",        TRUE, 0x0000ffff,0x0000ffff, FALSE),
  HOWTO( 2,              0,  2,   32, FALSE, 0, complain_overflow_bitfield,0,"32",        TRUE, 0xffffffff,0xffffffff, FALSE),
  HOWTO( 3,              2,  3,   26, TRUE,  0, complain_overflow_signed,  riscix_fix_pcrel_26 , "ARM26",      TRUE, 0x00ffffff,0x00ffffff, FALSE),
  HOWTO( 4,              0,  0,   8,  TRUE,  0, complain_overflow_signed,  0,"DISP8",     TRUE, 0x000000ff,0x000000ff, TRUE),
  HOWTO( 5,              0,  1,   16, TRUE,  0, complain_overflow_signed,  0,"DISP16",    TRUE, 0x0000ffff,0x0000ffff, TRUE),
  HOWTO( 6,              0,  2,   32, TRUE,  0, complain_overflow_signed,  0,"DISP32",    TRUE, 0xffffffff,0xffffffff, TRUE),
  HOWTO( 7,              2,  3,   26, FALSE, 0, complain_overflow_signed,  riscix_fix_pcrel_26_done, "ARM26D",TRUE,0x00ffffff,0x00ffffff, FALSE),
  EMPTY_HOWTO (-1),
  HOWTO( 9,              0, -1,   16, FALSE, 0, complain_overflow_bitfield,0,"NEG16",     TRUE, 0x0000ffff,0x0000ffff, FALSE),

}

Definition at line 171 of file riscix.c.