Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Typedefs | Functions | Variables
elf32-xstormy16.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/xstormy16.h"
#include "libiberty.h"
#include "elf32-target.h"

Go to the source code of this file.

Classes

struct  xstormy16_reloc_map
struct  relax_plt_data

Defines

#define ELF_ARCH   bfd_arch_xstormy16
#define ELF_MACHINE_CODE   EM_XSTORMY16
#define ELF_MAXPAGESIZE   0x100
#define TARGET_LITTLE_SYM   bfd_elf32_xstormy16_vec
#define TARGET_LITTLE_NAME   "elf32-xstormy16"
#define elf_info_to_howto_rel   NULL
#define elf_info_to_howto   xstormy16_info_to_howto_rela
#define elf_backend_relocate_section   xstormy16_elf_relocate_section
#define elf_backend_gc_mark_hook   xstormy16_elf_gc_mark_hook
#define elf_backend_check_relocs   xstormy16_elf_check_relocs
#define elf_backend_always_size_sections   xstormy16_elf_always_size_sections
#define elf_backend_omit_section_dynsym   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
#define elf_backend_finish_dynamic_sections   xstormy16_elf_finish_dynamic_sections
#define elf_backend_can_gc_sections   1
#define elf_backend_rela_normal   1
#define bfd_elf32_bfd_reloc_type_lookup   xstormy16_reloc_type_lookup
#define bfd_elf32_bfd_reloc_name_lookup   xstormy16_reloc_name_lookup
#define bfd_elf32_bfd_relax_section   xstormy16_elf_relax_section

Typedefs

typedef struct xstormy16_reloc_map reloc_map

Functions

static bfd_reloc_status_type xstormy16_elf_24_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, void *data, asection *input_section, bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
static reloc_howto_type * xstormy16_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
static reloc_howto_type * xstormy16_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
static void xstormy16_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, Elf_Internal_Rela *dst)
static bfd_boolean xstormy16_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec, const Elf_Internal_Rela *relocs)
static bfd_boolean xstormy16_relax_plt_check (struct elf_link_hash_entry *h, void *xdata)
static bfd_boolean xstormy16_relax_plt_realloc (struct elf_link_hash_entry *h, void *xdata)
static bfd_boolean xstormy16_elf_relax_section (bfd *dynobj, asection *splt, struct bfd_link_info *info, bfd_boolean *again)
static bfd_boolean xstormy16_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
static bfd_boolean xstormy16_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, struct bfd_link_info *info, bfd *input_bfd, asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms, asection **local_sections)
static bfd_boolean xstormy16_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
static asectionxstormy16_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info, Elf_Internal_Rela *rel, struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)

Variables

static reloc_howto_type xstormy16_elf_howto_table []
static reloc_howto_type xstormy16_elf_howto_table2 []
static const reloc_map xstormy16_reloc_map []

Class Documentation

struct xstormy16_reloc_map

Definition at line 306 of file elf32-xstormy16.c.

Class Members
bfd_reloc_code_real_type bfd_reloc_val
reloc_howto_type * table
unsigned int xstormy16_reloc_val
struct relax_plt_data

Definition at line 992 of file elf32-m32c.c.

Collaboration diagram for relax_plt_data:
Class Members
bfd_boolean * again
asection * splt

Define Documentation

Definition at line 1049 of file elf32-xstormy16.c.

Definition at line 1047 of file elf32-xstormy16.c.

Definition at line 1046 of file elf32-xstormy16.c.

Definition at line 1024 of file elf32-xstormy16.c.

Definition at line 1036 of file elf32-xstormy16.c.

Definition at line 1043 of file elf32-xstormy16.c.

Definition at line 1035 of file elf32-xstormy16.c.

Definition at line 1040 of file elf32-xstormy16.c.

Definition at line 1034 of file elf32-xstormy16.c.

Definition at line 1038 of file elf32-xstormy16.c.

#define elf_backend_rela_normal   1

Definition at line 1044 of file elf32-xstormy16.c.

Definition at line 1033 of file elf32-xstormy16.c.

Definition at line 1032 of file elf32-xstormy16.c.

Definition at line 1031 of file elf32-xstormy16.c.

Definition at line 1025 of file elf32-xstormy16.c.

#define ELF_MAXPAGESIZE   0x100

Definition at line 1026 of file elf32-xstormy16.c.

#define TARGET_LITTLE_NAME   "elf32-xstormy16"

Definition at line 1029 of file elf32-xstormy16.c.

Definition at line 1028 of file elf32-xstormy16.c.


Typedef Documentation


Function Documentation

static bfd_reloc_status_type xstormy16_elf_24_reloc ( bfd abfd,
arelent reloc_entry,
asymbol symbol,
void *  data,
asection input_section,
bfd output_bfd,
char **error_message  ATTRIBUTE_UNUSED 
) [static]

Definition at line 32 of file elf32-xstormy16.c.

{
  bfd_vma relocation, x;

  if (output_bfd != NULL)
    {
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }

  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
    return bfd_reloc_outofrange;

  if (bfd_is_com_section (symbol->section))
    relocation = 0;
  else
    relocation = symbol->value;

  relocation += symbol->section->output_section->vma;
  relocation += symbol->section->output_offset;
  relocation += reloc_entry->addend;

  x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
  x &= 0x0000ff00;
  x |= relocation & 0xff;
  x |= (relocation << 8) & 0xffff0000;
  bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);

  if (relocation & ~ (bfd_vma) 0xffffff)
    return bfd_reloc_overflow;

  return bfd_reloc_ok;
}
static bfd_boolean xstormy16_elf_always_size_sections ( bfd *output_bfd  ATTRIBUTE_UNUSED,
struct bfd_link_info info 
) [static]

Definition at line 713 of file elf32-xstormy16.c.

{
  bfd *dynobj;
  asection *splt;

  if (info->relocatable)
    return TRUE;

  dynobj = elf_hash_table (info)->dynobj;
  if (dynobj == NULL)
    return TRUE;

  splt = bfd_get_section_by_name (dynobj, ".plt");
  BFD_ASSERT (splt != NULL);

  splt->contents = bfd_zalloc (dynobj, splt->size);
  if (splt->contents == NULL)
    return FALSE;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean xstormy16_elf_check_relocs ( bfd abfd,
struct bfd_link_info info,
asection sec,
const Elf_Internal_Rela relocs 
) [static]

Definition at line 403 of file elf32-xstormy16.c.

{
  const Elf_Internal_Rela *rel, *relend;
  struct elf_link_hash_entry **sym_hashes;
  Elf_Internal_Shdr *symtab_hdr;
  bfd_vma *local_plt_offsets;
  asection *splt;
  bfd *dynobj;

  if (info->relocatable)
    return TRUE;

  symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (abfd);
  local_plt_offsets = elf_local_got_offsets (abfd);
  splt = NULL;
  dynobj = elf_hash_table(info)->dynobj;

  relend = relocs + sec->reloc_count;
  for (rel = relocs; rel < relend; ++rel)
    {
      unsigned long r_symndx;
      struct elf_link_hash_entry *h;
      bfd_vma *offset;

      r_symndx = ELF32_R_SYM (rel->r_info);
      if (r_symndx < symtab_hdr->sh_info)
       h = NULL;
      else
       {
         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
         while (h->root.type == bfd_link_hash_indirect
               || h->root.type == bfd_link_hash_warning)
           h = (struct elf_link_hash_entry *) h->root.u.i.link;
       }

      switch (ELF32_R_TYPE (rel->r_info))
        {
         /* This relocation describes a 16-bit pointer to a function.
            We may need to allocate a thunk in low memory; reserve memory
            for it now.  */
       case R_XSTORMY16_FPTR16:
         if (rel->r_addend != 0)
           {
             (*info->callbacks->warning)
              (info, _("non-zero addend in @fptr reloc"), 0,
               abfd, 0, 0);
           }

         if (dynobj == NULL)
           elf_hash_table (info)->dynobj = dynobj = abfd;
         if (splt == NULL)
           {
             splt = bfd_get_section_by_name (dynobj, ".plt");
             if (splt == NULL)
              {
                splt = bfd_make_section_with_flags (dynobj, ".plt",
                                                (SEC_ALLOC
                                                 | SEC_LOAD
                                                 | SEC_HAS_CONTENTS
                                                 | SEC_IN_MEMORY
                                                 | SEC_LINKER_CREATED
                                                 | SEC_READONLY
                                                 | SEC_CODE));

                if (splt == NULL
                    || ! bfd_set_section_alignment (dynobj, splt, 1))
                  return FALSE;
              }
           }

         if (h != NULL)
           offset = &h->plt.offset;
         else
           {
             if (local_plt_offsets == NULL)
              {
                size_t size;
                unsigned int i;

                size = symtab_hdr->sh_info * sizeof (bfd_vma);
                local_plt_offsets = bfd_alloc (abfd, size);
                if (local_plt_offsets == NULL)
                  return FALSE;
                elf_local_got_offsets (abfd) = local_plt_offsets;

                for (i = 0; i < symtab_hdr->sh_info; i++)
                  local_plt_offsets[i] = (bfd_vma) -1;
              }
             offset = &local_plt_offsets[r_symndx];
           }

         if (*offset == (bfd_vma) -1)
           {
             *offset = splt->size;
             splt->size += 4;
           }
         break;

         /* This relocation describes the C++ object vtable hierarchy.
            Reconstruct it for later use during GC.  */
        case R_XSTORMY16_GNU_VTINHERIT:
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
            return FALSE;
          break;

         /* This relocation describes which C++ vtable entries are actually
            used.  Record for later use during GC.  */
        case R_XSTORMY16_GNU_VTENTRY:
          if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
            return FALSE;
          break;
       }
    }

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean xstormy16_elf_finish_dynamic_sections ( bfd *abfd  ATTRIBUTE_UNUSED,
struct bfd_link_info info 
) [static]

Definition at line 977 of file elf32-xstormy16.c.

{
  bfd *dynobj;
  asection *splt;

  /* As an extra sanity check, verify that all plt entries have
     been filled in.  */

  if ((dynobj = elf_hash_table (info)->dynobj) != NULL
      && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
    {
      bfd_byte *contents = splt->contents;
      unsigned int i, size = splt->size;

      for (i = 0; i < size; i += 4)
       {
         unsigned int x = bfd_get_32 (dynobj, contents + i);

         BFD_ASSERT (x != 0);
       }
    }

  return TRUE;
}

Here is the call graph for this function:

static asection* xstormy16_elf_gc_mark_hook ( asection sec,
struct bfd_link_info info,
Elf_Internal_Rela rel,
struct elf_link_hash_entry h,
Elf_Internal_Sym *  sym 
) [static]

Definition at line 1007 of file elf32-xstormy16.c.

{
  if (h != NULL)
    switch (ELF32_R_TYPE (rel->r_info))
      {
      case R_XSTORMY16_GNU_VTINHERIT:
      case R_XSTORMY16_GNU_VTENTRY:
       return NULL;
      }

  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
}

Here is the call graph for this function:

static bfd_boolean xstormy16_elf_relax_section ( bfd dynobj,
asection splt,
struct bfd_link_info info,
bfd_boolean again 
) [static]

Definition at line 585 of file elf32-xstormy16.c.

{
  struct relax_plt_data relax_plt_data;
  bfd *ibfd;

  /* Assume nothing changes.  */
  *again = FALSE;

  if (info->relocatable)
    return TRUE;

  /* We only relax the .plt section at the moment.  */
  if (dynobj != elf_hash_table (info)->dynobj
      || strcmp (splt->name, ".plt") != 0)
    return TRUE;

  /* Quick check for an empty plt.  */
  if (splt->size == 0)
    return TRUE;

  /* Map across all global symbols; see which ones happen to
     fall in the low 64k.  */
  relax_plt_data.splt = splt;
  relax_plt_data.again = again;
  elf_link_hash_traverse (elf_hash_table (info), xstormy16_relax_plt_check,
                       &relax_plt_data);

  /* Likewise for local symbols, though that's somewhat less convenient
     as we have to walk the list of input bfds and swap in symbol data.  */
  for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
    {
      bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
      Elf_Internal_Shdr *symtab_hdr;
      Elf_Internal_Sym *isymbuf = NULL;
      unsigned int idx;

      if (! local_plt_offsets)
       continue;

      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
      if (symtab_hdr->sh_info != 0)
       {
         isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
         if (isymbuf == NULL)
           isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
                                       symtab_hdr->sh_info, 0,
                                       NULL, NULL, NULL);
         if (isymbuf == NULL)
           return FALSE;
       }

      for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
       {
         Elf_Internal_Sym *isym;
         asection *tsec;
         bfd_vma address;

         if (local_plt_offsets[idx] == (bfd_vma) -1)
           continue;

         isym = &isymbuf[idx];
         if (isym->st_shndx == SHN_UNDEF)
           continue;
         else if (isym->st_shndx == SHN_ABS)
           tsec = bfd_abs_section_ptr;
         else if (isym->st_shndx == SHN_COMMON)
           tsec = bfd_com_section_ptr;
         else
           tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);

         address = (tsec->output_section->vma
                   + tsec->output_offset
                   + isym->st_value);
         if (address <= 0xffff)
           {
             local_plt_offsets[idx] = -1;
             splt->size -= 4;
             *again = TRUE;
           }
       }

      if (isymbuf != NULL
         && symtab_hdr->contents != (unsigned char *) isymbuf)
       {
         if (! info->keep_memory)
           free (isymbuf);
         else
           {
             /* Cache the symbols for elf_link_input_bfd.  */
             symtab_hdr->contents = (unsigned char *) isymbuf;
           }
       }
    }

  /* If we changed anything, walk the symbols again to reallocate
     .plt entry addresses.  */
  if (*again && splt->size > 0)
    {
      bfd_vma entry = 0;

      elf_link_hash_traverse (elf_hash_table (info),
                           xstormy16_relax_plt_realloc, &entry);

      for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
       {
         bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
         unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
         unsigned int idx;

         if (! local_plt_offsets)
           continue;

         for (idx = 0; idx < nlocals; ++idx)
           if (local_plt_offsets[idx] != (bfd_vma) -1)
             {
               local_plt_offsets[idx] = entry;
              entry += 4;
             }
       }
    }

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean xstormy16_elf_relocate_section ( bfd *output_bfd  ATTRIBUTE_UNUSED,
struct bfd_link_info info,
bfd input_bfd,
asection input_section,
bfd_byte contents,
Elf_Internal_Rela relocs,
Elf_Internal_Sym *  local_syms,
asection **  local_sections 
) [static]

Definition at line 767 of file elf32-xstormy16.c.

{
  Elf_Internal_Shdr *           symtab_hdr;
  struct elf_link_hash_entry ** sym_hashes;
  Elf_Internal_Rela *           rel;
  Elf_Internal_Rela *           relend;
  bfd *dynobj;
  asection *splt;

  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (input_bfd);
  relend     = relocs + input_section->reloc_count;

  dynobj = elf_hash_table (info)->dynobj;
  splt = NULL;
  if (dynobj != NULL)
    splt = bfd_get_section_by_name (dynobj, ".plt");

  for (rel = relocs; rel < relend; rel ++)
    {
      reloc_howto_type *           howto;
      unsigned long                r_symndx;
      Elf_Internal_Sym *           sym;
      asection *                   sec;
      struct elf_link_hash_entry * h;
      bfd_vma                      relocation;
      bfd_reloc_status_type        r;
      const char *                 name = NULL;
      int                          r_type;

      r_type = ELF32_R_TYPE (rel->r_info);

      if (   r_type == R_XSTORMY16_GNU_VTINHERIT
         || r_type == R_XSTORMY16_GNU_VTENTRY)
       continue;

      r_symndx = ELF32_R_SYM (rel->r_info);
      howto  = xstormy16_elf_howto_table + ELF32_R_TYPE (rel->r_info);
      h      = NULL;
      sym    = NULL;
      sec    = NULL;

      if (r_symndx < symtab_hdr->sh_info)
       {
         sym = local_syms + r_symndx;
         sec = local_sections [r_symndx];
         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
       }
      else
       {
         bfd_boolean unresolved_reloc, warned;

         RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
                               r_symndx, symtab_hdr, sym_hashes,
                               h, sec, relocation,
                               unresolved_reloc, warned);
       }

      if (sec != NULL && elf_discarded_section (sec))
       {
         /* For relocs against symbols from removed linkonce sections,
            or sections discarded by a linker script, we just want the
            section contents zeroed.  Avoid any special processing.  */
         _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
         rel->r_info = 0;
         rel->r_addend = 0;
         continue;
       }

      if (info->relocatable)
       continue;

      if (h != NULL)
       name = h->root.root.string;
      else
       {
         name = (bfd_elf_string_from_elf_section
                (input_bfd, symtab_hdr->sh_link, sym->st_name));
         if (name == NULL || *name == '\0')
           name = bfd_section_name (input_bfd, sec);
       }

      switch (ELF32_R_TYPE (rel->r_info))
       {
       case R_XSTORMY16_24:
         {
           bfd_vma reloc = relocation + rel->r_addend;
           unsigned int x;

           x = bfd_get_32 (input_bfd, contents + rel->r_offset);
           x &= 0x0000ff00;
           x |= reloc & 0xff;
           x |= (reloc << 8) & 0xffff0000;
           bfd_put_32 (input_bfd, x, contents + rel->r_offset);

           if (reloc & ~0xffffff)
             r = bfd_reloc_overflow;
           else
             r = bfd_reloc_ok;
           break;
         }

       case R_XSTORMY16_FPTR16:
         {
           bfd_vma *plt_offset;

           if (h != NULL)
             plt_offset = &h->plt.offset;
           else
             plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;

           if (relocation <= 0xffff)
             {
               /* If the symbol is in range for a 16-bit address, we should
                 have deallocated the plt entry in relax_section.  */
               BFD_ASSERT (*plt_offset == (bfd_vma) -1);
             }
           else
             {
              /* If the symbol is out of range for a 16-bit address,
                 we must have allocated a plt entry.  */
              BFD_ASSERT (*plt_offset != (bfd_vma) -1);

              /* If this is the first time we've processed this symbol,
                 fill in the plt entry with the correct symbol address.  */
              if ((*plt_offset & 1) == 0)
                {
                  unsigned int x;

                  x = 0x00000200;  /* jmpf */
                  x |= relocation & 0xff;
                  x |= (relocation << 8) & 0xffff0000;
                  bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
                  *plt_offset |= 1;
                }

              relocation = (splt->output_section->vma
                           + splt->output_offset
                           + (*plt_offset & -2));
             }
           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
                                     contents, rel->r_offset,
                                     relocation, 0);
           break;
         }

       default:
         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
                                   contents, rel->r_offset,
                                   relocation, rel->r_addend);
         break;
       }

      if (r != bfd_reloc_ok)
       {
         const char * msg = NULL;

         switch (r)
           {
           case bfd_reloc_overflow:
             r = info->callbacks->reloc_overflow
              (info, (h ? &h->root : NULL), name, howto->name,
               (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
             break;

           case bfd_reloc_undefined:
             r = info->callbacks->undefined_symbol
              (info, name, input_bfd, input_section, rel->r_offset,
               TRUE);
             break;

           case bfd_reloc_outofrange:
             msg = _("internal error: out of range error");
             break;

           case bfd_reloc_notsupported:
             msg = _("internal error: unsupported relocation error");
             break;

           case bfd_reloc_dangerous:
             msg = _("internal error: dangerous relocation");
             break;

           default:
             msg = _("internal error: unknown error");
             break;
           }

         if (msg)
           r = info->callbacks->warning
             (info, msg, name, input_bfd, input_section, rel->r_offset);

         if (! r)
           return FALSE;
       }
    }

  return TRUE;
}

Here is the call graph for this function:

static void xstormy16_info_to_howto_rela ( bfd *abfd  ATTRIBUTE_UNUSED,
arelent cache_ptr,
Elf_Internal_Rela dst 
) [static]

Definition at line 380 of file elf32-xstormy16.c.

{
  unsigned int r_type = ELF32_R_TYPE (dst->r_info);

  if (r_type <= (unsigned int) R_XSTORMY16_12)
    cache_ptr->howto = &xstormy16_elf_howto_table [r_type];
  else if (r_type - R_XSTORMY16_GNU_VTINHERIT
          <= (unsigned int) R_XSTORMY16_GNU_VTENTRY)
    cache_ptr->howto
      = &xstormy16_elf_howto_table2 [r_type - R_XSTORMY16_GNU_VTINHERIT];
  else
    abort ();
}
static bfd_boolean xstormy16_relax_plt_check ( struct elf_link_hash_entry h,
void *  xdata 
) [static]

Definition at line 534 of file elf32-xstormy16.c.

{
  struct relax_plt_data *data = (struct relax_plt_data *) xdata;

  if (h->root.type == bfd_link_hash_warning)
    h = (struct elf_link_hash_entry *) h->root.u.i.link;

  if (h->plt.offset != (bfd_vma) -1)
    {
      bfd_vma address;

      if (h->root.type == bfd_link_hash_undefined
         || h->root.type == bfd_link_hash_undefweak)
       address = 0;
      else
       address = (h->root.u.def.section->output_section->vma
                 + h->root.u.def.section->output_offset
                 + h->root.u.def.value);

      if (address <= 0xffff)
       {
         h->plt.offset = -1;
         data->splt->size -= 4;
         *data->again = TRUE;
       }
    }

  return TRUE;
}

Here is the caller graph for this function:

static bfd_boolean xstormy16_relax_plt_realloc ( struct elf_link_hash_entry h,
void *  xdata 
) [static]

Definition at line 568 of file elf32-xstormy16.c.

{
  bfd_vma *entry = (bfd_vma *) xdata;

  if (h->root.type == bfd_link_hash_warning)
    h = (struct elf_link_hash_entry *) h->root.u.i.link;

  if (h->plt.offset != (bfd_vma) -1)
    {
      h->plt.offset = *entry;
      *entry += 4;
    }

  return TRUE;
}

Here is the caller graph for this function:

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

Definition at line 353 of file elf32-xstormy16.c.

{
  unsigned int i;

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

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

  return NULL;
}

Here is the call graph for this function:

static reloc_howto_type* xstormy16_reloc_type_lookup ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_reloc_code_real_type  code 
) [static]

Definition at line 333 of file elf32-xstormy16.c.

{
  unsigned int i;

  for (i = ARRAY_SIZE (xstormy16_reloc_map); --i;)
    {
      const reloc_map * entry;

      entry = xstormy16_reloc_map + i;

      if (entry->bfd_reloc_val == code)
       return entry->table + (entry->xstormy16_reloc_val
                            - entry->table[0].type);
    }

  return NULL;
}

Variable Documentation

reloc_howto_type xstormy16_elf_howto_table[] [static]

Definition at line 72 of file elf32-xstormy16.c.

reloc_howto_type xstormy16_elf_howto_table2[] [static]

Definition at line 270 of file elf32-xstormy16.c.

Initial value:

Definition at line 313 of file elf32-xstormy16.c.