Back to index

cell-binutils  2.17cvs20070401
Defines | Functions | Variables
nlm32-i386.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "nlm/i386-ext.h"
#include "libnlm.h"
#include "nlmswap.h"
#include "nlm-target.h"

Go to the source code of this file.

Defines

#define ARCH_SIZE   32
#define Nlm_External_Fixed_Header   Nlm32_i386_External_Fixed_Header
#define TARGET_LITTLE_NAME   "nlm32-i386"
#define TARGET_LITTLE_SYM   nlmNAME (i386_vec)
#define TARGET_BACKEND_DATA   & nlm32_i386_backend

Functions

static bfd_boolean nlm_i386_read_reloc (bfd *abfd, nlmNAME(symbol_type)*sym, asection **secp, arelent *rel)
static bfd_boolean nlm_i386_write_import (bfd *abfd, asection *sec, arelent *rel)
static bfd_boolean nlm_i386_mangle_relocs (bfd *abfd, asection *sec, const PTR data, bfd_vma offset, bfd_size_type count)
static bfd_boolean nlm_i386_read_import (bfd *abfd, nlmNAME(symbol_type)*sym)
static bfd_boolean nlm_i386_write_external (bfd *abfd, bfd_size_type count, asymbol *sym, struct reloc_and_sec *relocs)

Variables

static reloc_howto_type nlm_i386_abs_howto
static reloc_howto_type nlm_i386_pcrel_howto
static struct nlm_backend_data

Define Documentation

#define ARCH_SIZE   32

Definition at line 25 of file nlm32-i386.c.

Definition at line 28 of file nlm32-i386.c.

#define TARGET_BACKEND_DATA   & nlm32_i386_backend

Definition at line 427 of file nlm32-i386.c.

#define TARGET_LITTLE_NAME   "nlm32-i386"

Definition at line 425 of file nlm32-i386.c.

#define TARGET_LITTLE_SYM   nlmNAME (i386_vec)

Definition at line 426 of file nlm32-i386.c.


Function Documentation

static bfd_boolean nlm_i386_mangle_relocs ( bfd abfd,
asection sec,
const PTR  data,
bfd_vma  offset,
bfd_size_type  count 
) [static]

Definition at line 233 of file nlm32-i386.c.

{
  arelent **rel_ptr_ptr, **rel_end;

  rel_ptr_ptr = sec->orelocation;
  rel_end = rel_ptr_ptr + sec->reloc_count;
  for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
    {
      arelent *rel;
      asymbol *sym;
      bfd_vma addend;

      rel = *rel_ptr_ptr;
      sym = *rel->sym_ptr_ptr;

      /* Note that no serious harm will ensue if we fail to change a
        reloc.  We will wind up failing in nlm_i386_write_import.  */

      /* Make sure this reloc is within the data we have.  We only 4
        byte relocs here, so we insist on having 4 bytes.  */
      if (rel->address < offset
         || rel->address + 4 > offset + count)
       continue;

      /* NetWare doesn't support reloc addends, so we get rid of them
        here by simply adding them into the object data.  We handle
        the symbol value, if any, the same way.  */
      addend = rel->addend + sym->value;

      /* The value of a symbol is the offset into the section.  If the
        symbol is in the .bss segment, we need to include the size of
        the data segment in the offset as well.  Fortunately, we know
        that at this point the size of the data section is in the NLM
        header.  */
      if (((bfd_get_section_flags (abfd, bfd_get_section (sym))
           & SEC_LOAD) == 0)
         && ((bfd_get_section_flags (abfd, bfd_get_section (sym))
              & SEC_ALLOC) != 0))
       addend += nlm_fixed_header (abfd)->dataImageSize;

      if (addend != 0
         && rel->howto != NULL
         && rel->howto->rightshift == 0
         && rel->howto->size == 2
         && rel->howto->bitsize == 32
         && rel->howto->bitpos == 0
         && rel->howto->src_mask == 0xffffffff
         && rel->howto->dst_mask == 0xffffffff)
       {
         bfd_vma val;

         val = bfd_get_32 (abfd, (bfd_byte *) data + rel->address - offset);
         val += addend;
         bfd_put_32 (abfd, val, (bfd_byte *) data + rel->address - offset);
         rel->addend = 0;
       }

      /* NetWare uses a reloc with pcrel_offset set.  We adjust
        pc_relative relocs accordingly.  We are going to change the
        howto field, so we can only do this if the current one is
        compatible.  We should check special_function here, but at
        the moment coff-i386 uses a special_function which does not
        affect what we are doing here.  */
      if (rel->howto != NULL
         && rel->howto->pc_relative
         && ! rel->howto->pcrel_offset
         && rel->howto->rightshift == 0
         && rel->howto->size == 2
         && rel->howto->bitsize == 32
         && rel->howto->bitpos == 0
         && rel->howto->src_mask == 0xffffffff
         && rel->howto->dst_mask == 0xffffffff)
       {
         bfd_vma val;

         /* When pcrel_offset is not set, it means that the negative
            of the address of the memory location is stored in the
            memory location.  We must add it back in.  */
         val = bfd_get_32 (abfd, (bfd_byte *) data + rel->address - offset);
         val += rel->address;
         bfd_put_32 (abfd, val, (bfd_byte *) data + rel->address - offset);

         rel->howto = &nlm_i386_pcrel_howto;
       }
    }

  return TRUE;
}
static bfd_boolean nlm_i386_read_import ( bfd abfd,
nlmNAME(symbol_type)*  sym 
) [static]

Definition at line 329 of file nlm32-i386.c.

{
  struct nlm_relent *nlm_relocs;   /* Relocation records for symbol.  */
  bfd_size_type rcount;                   /* Number of relocs.  */
  bfd_byte temp[NLM_TARGET_LONG_SIZE];    /* Temporary 32-bit value.  */
  unsigned char symlength;         /* Length of symbol name.  */
  char *name;

  if (bfd_bread (& symlength, (bfd_size_type) sizeof (symlength), abfd)
      != sizeof (symlength))
    return FALSE;
  sym -> symbol.the_bfd = abfd;
  name = bfd_alloc (abfd, (bfd_size_type) symlength + 1);
  if (name == NULL)
    return FALSE;
  if (bfd_bread (name, (bfd_size_type) symlength, abfd) != symlength)
    return FALSE;
  name[symlength] = '\0';
  sym -> symbol.name = name;
  sym -> symbol.flags = 0;
  sym -> symbol.value = 0;
  sym -> symbol.section = bfd_und_section_ptr;
  if (bfd_bread (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
    return FALSE;
  rcount = H_GET_32 (abfd, temp);
  nlm_relocs = bfd_alloc (abfd, rcount * sizeof (struct nlm_relent));
  if (!nlm_relocs)
    return FALSE;
  sym -> relocs = nlm_relocs;
  sym -> rcnt = 0;
  while (sym -> rcnt < rcount)
    {
      asection *section;

      if (! nlm_i386_read_reloc (abfd, sym, &section, &nlm_relocs -> reloc))
       return FALSE;
      nlm_relocs -> section = section;
      nlm_relocs++;
      sym -> rcnt++;
    }
  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean nlm_i386_read_reloc ( bfd abfd,
nlmNAME(symbol_type)*  sym,
asection **  secp,
arelent rel 
) [static]

Definition at line 69 of file nlm32-i386.c.

{
  bfd_byte temp[4];
  bfd_vma val;
  const char *name;

  if (bfd_bread (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
    return FALSE;

  val = bfd_get_32 (abfd, temp);

  /* The value is an offset into either the code or data segment.
     This is the location which needs to be adjusted.

     If this is a relocation fixup rather than an imported symbol (the
     sym argument is NULL) then the high bit is 0 if the location
     needs to be adjusted by the address of the data segment, or 1 if
     the location needs to be adjusted by the address of the code
     segment.  If this is an imported symbol, then the high bit is 0
     if the location is 0 if the location should be adjusted by the
     offset to the symbol, or 1 if the location should adjusted by the
     absolute value of the symbol.

     The second most significant bit is 0 if the value is an offset
     into the data segment, or 1 if the value is an offset into the
     code segment.

     All this translates fairly easily into a BFD reloc.  */

  if (sym == NULL)
    {
      if ((val & NLM_HIBIT) == 0)
       name = NLM_INITIALIZED_DATA_NAME;
      else
       {
         name = NLM_CODE_NAME;
         val &=~ NLM_HIBIT;
       }
      rel->sym_ptr_ptr = bfd_get_section_by_name (abfd, name)->symbol_ptr_ptr;
      rel->howto = &nlm_i386_abs_howto;
    }
  else
    {
      /* In this case we do not need to set the sym_ptr_ptr field.  */
      rel->sym_ptr_ptr = NULL;
      if ((val & NLM_HIBIT) == 0)
       rel->howto = &nlm_i386_pcrel_howto;
      else
       {
         rel->howto = &nlm_i386_abs_howto;
         val &=~ NLM_HIBIT;
       }
    }

  if ((val & (NLM_HIBIT >> 1)) == 0)
    *secp = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
  else
    {
      *secp = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
      val &=~ (NLM_HIBIT >> 1);
    }

  rel->address = val;
  rel->addend = 0;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean nlm_i386_write_external ( bfd abfd,
bfd_size_type  count,
asymbol sym,
struct reloc_and_sec relocs 
) [static]

Definition at line 375 of file nlm32-i386.c.

{
  unsigned int i;
  bfd_byte len;
  unsigned char temp[NLM_TARGET_LONG_SIZE];

  len = strlen (sym->name);
  if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
       != sizeof (bfd_byte))
      || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
    return FALSE;

  bfd_put_32 (abfd, count, temp);
  if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
    return FALSE;

  for (i = 0; i < count; i++)
    if (! nlm_i386_write_import (abfd, relocs[i].sec, relocs[i].rel))
      return FALSE;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean nlm_i386_write_import ( bfd abfd,
asection sec,
arelent rel 
) [static]

Definition at line 143 of file nlm32-i386.c.

{
  asymbol *sym;
  bfd_vma val;
  bfd_byte temp[4];

  /* NetWare only supports two kinds of relocs.  We should check
     special_function here, as well, but at the moment coff-i386
     relocs uses a special_function which does not affect what we do
     here.  */
  if (rel->addend != 0
      || rel->howto == NULL
      || rel->howto->rightshift != 0
      || rel->howto->size != 2
      || rel->howto->bitsize != 32
      || rel->howto->bitpos != 0
      || rel->howto->src_mask != 0xffffffff
      || rel->howto->dst_mask != 0xffffffff)
    {
      bfd_set_error (bfd_error_invalid_operation);
      return FALSE;
    }

  sym = *rel->sym_ptr_ptr;

  /* The value we write out is the offset into the appropriate
     segment.  This offset is the section vma, adjusted by the vma of
     the lowest section in that segment, plus the address of the
     relocation.  */
  val = bfd_get_section_vma (abfd, sec) + rel->address;

  /* The second most significant bit is 0 if the value is an offset
     into the data segment, or 1 if the value is an offset into the
     code segment.  */
  if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
    {
      val -= nlm_get_text_low (abfd);
      val |= NLM_HIBIT >> 1;
    }
  else
    val -= nlm_get_data_low (abfd);

  if (! bfd_is_und_section (bfd_get_section (sym)))
    {
      /* NetWare only supports absolute internal relocs.  */
      if (rel->howto->pc_relative)
       {
         bfd_set_error (bfd_error_invalid_operation);
         return FALSE;
       }

      /* The high bit is 1 if the reloc is against the code section, 0
        if against the data section.  */
      if (bfd_get_section_flags (abfd, bfd_get_section (sym)) & SEC_CODE)
       val |= NLM_HIBIT;
    }
  else
    {
      /* The high bit is 1 if this is an absolute reloc, 0 if it is PC
        relative.  */
      if (! rel->howto->pc_relative)
       val |= NLM_HIBIT;
      else
       {
         /* PC relative relocs on NetWare must be pcrel_offset.  */
         if (! rel->howto->pcrel_offset)
           {
             bfd_set_error (bfd_error_invalid_operation);
             return FALSE;
           }
       }
    }

  bfd_put_32 (abfd, val, temp);
  if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
    return FALSE;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

reloc_howto_type nlm_i386_abs_howto [static]
Initial value:
  HOWTO (0,                 
        0,                  
        2,                  
        32,                 
        FALSE,                     
        0,                  
        complain_overflow_bitfield, 
        0,                  
        "32",               
        TRUE,               
        0xffffffff,         
        0xffffffff,         
        FALSE)

Definition at line 34 of file nlm32-i386.c.

reloc_howto_type nlm_i386_pcrel_howto [static]
Initial value:
  HOWTO (1,                 
        0,                  
        2,                  
        32,                 
        TRUE,               
        0,                  
        complain_overflow_signed, 
        0,                  
        "DISP32",           
        TRUE,               
        0xffffffff,         
        0xffffffff,         
        TRUE)

Definition at line 51 of file nlm32-i386.c.