Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Functions | Variables
elf32-sh64.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "elf-bfd.h"
#include "../opcodes/sh64-opc.h"
#include "elf32-sh64.h"
#include "elf32-sh.c"
#include "elf32-target.h"

Go to the source code of this file.

Classes

struct  sh64_find_section_vma_data

Defines

#define SH64_ELF
#define DATALABEL_SUFFIX   " DL"
#define sh_elf_copy_private_data   sh64_elf_copy_private_data
#define sh_elf_merge_private_data   sh64_elf_merge_private_data
#define sh_elf_set_private_flags   sh64_elf_set_private_flags
#define bfd_elf32_bfd_set_private_flags   sh64_elf_set_private_flags
#define sh_elf_set_mach_from_flags   sh64_elf_set_mach_from_flags
#define elf_backend_sign_extend_vma   1
#define elf_backend_fake_sections   sh64_elf_fake_sections
#define elf_backend_get_symbol_type   sh64_elf_get_symbol_type
#define elf_backend_add_symbol_hook   sh64_elf_add_symbol_hook
#define elf_backend_link_output_symbol_hook   sh64_elf_link_output_symbol_hook
#define elf_backend_merge_symbol_attribute   sh64_elf_merge_symbol_attribute
#define elf_backend_final_write_processing   sh64_elf_final_write_processing
#define elf_backend_section_from_shdr   sh64_backend_section_from_shdr
#define elf_backend_special_sections   sh64_elf_special_sections
#define elf_backend_section_flags   sh64_elf_section_flags
#define bfd_elf32_new_section_hook   sh64_elf_new_section_hook
#define bfd_elf32_bfd_copy_private_section_data   sh64_bfd_elf_copy_private_section_data
#define _bfd_sh_align_load_span(a, b, c, d, e, f, g, h, i, j)   TRUE
#define GOT_BIAS   (-((long)-32768))
#define INCLUDE_SHMEDIA
#define SH_TARGET_ALREADY_DEFINED
#define TARGET_BIG_SYM   bfd_elf32_sh64_vec
#define TARGET_BIG_NAME   "elf32-sh64"
#define TARGET_LITTLE_SYM   bfd_elf32_sh64l_vec
#define TARGET_LITTLE_NAME   "elf32-sh64l"
#define TARGET_BIG_SYM   bfd_elf32_sh64nbsd_vec
#define TARGET_BIG_NAME   "elf32-sh64-nbsd"
#define TARGET_LITTLE_SYM   bfd_elf32_sh64lnbsd_vec
#define TARGET_LITTLE_NAME   "elf32-sh64l-nbsd"
#define ELF_MAXPAGESIZE   0x10000
#define elf_symbol_leading_char   0
#define elf32_bed   elf32_sh64_nbsd_bed
#define TARGET_BIG_SYM   bfd_elf32_sh64blin_vec
#define TARGET_BIG_NAME   "elf32-sh64big-linux"
#define TARGET_LITTLE_SYM   bfd_elf32_sh64lin_vec
#define TARGET_LITTLE_NAME   "elf32-sh64-linux"
#define elf32_bed   elf32_sh64_lin_bed
#define ELF_COMMONPAGESIZE   0x1000

Functions

static bfd_boolean sh64_elf_new_section_hook (bfd *, asection *)
static bfd_boolean sh64_elf_copy_private_data (bfd *, bfd *)
static bfd_boolean sh64_elf_merge_private_data (bfd *, bfd *)
static bfd_boolean sh64_elf_fake_sections (bfd *, Elf_Internal_Shdr *, asection *)
static bfd_boolean sh64_elf_set_private_flags (bfd *, flagword)
static bfd_boolean sh64_elf_set_mach_from_flags (bfd *)
static bfd_boolean shmedia_prepare_reloc (struct bfd_link_info *, bfd *, asection *, bfd_byte *, const Elf_Internal_Rela *, bfd_vma *)
static int sh64_elf_get_symbol_type (Elf_Internal_Sym *, int)
static bfd_boolean sh64_elf_add_symbol_hook (bfd *, struct bfd_link_info *, Elf_Internal_Sym *, const char **, flagword *, asection **, bfd_vma *)
static bfd_boolean sh64_elf_link_output_symbol_hook (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *, struct elf_link_hash_entry *)
static bfd_boolean sh64_backend_section_from_shdr (bfd *, Elf_Internal_Shdr *, const char *, int)
static void sh64_elf_final_write_processing (bfd *, bfd_boolean)
static bfd_boolean sh64_bfd_elf_copy_private_section_data (bfd *, asection *, bfd *, asection *)
static void sh64_find_section_for_address (bfd *, asection *, void *)
bfd_boolean sh64_elf_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *elf_section_hdr, asection *asect)
static bfd_boolean sh64_elf_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
static bfd_boolean sh64_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, Elf_Internal_Sym *sym, const char **namep, flagword *flagsp ATTRIBUTE_UNUSED, asection **secp, bfd_vma *valp)
bfd_boolean sh64_elf_link_output_symbol_hook (struct bfd_link_info *info, const char *cname, Elf_Internal_Sym *sym, asection *input_sec ATTRIBUTE_UNUSED, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
static void sh64_find_section_for_address (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *data)
static void sh64_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
static void sh64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h, const Elf_Internal_Sym *isym, bfd_boolean definition, bfd_boolean dynamic ATTRIBUTE_UNUSED)

Variables

static struct bfd_elf_special_section []

Class Documentation

struct sh64_find_section_vma_data

Definition at line 36 of file elf32-sh64.c.

Collaboration diagram for sh64_find_section_vma_data:
Class Members
bfd_vma addr
asection * section

Define Documentation

#define _bfd_sh_align_load_span (   a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j 
)    TRUE

Definition at line 106 of file elf32-sh64.c.

Definition at line 100 of file elf32-sh64.c.

Definition at line 80 of file elf32-sh64.c.

Definition at line 95 of file elf32-sh64.c.

#define DATALABEL_SUFFIX   " DL"

Definition at line 33 of file elf32-sh64.c.

#define elf32_bed   elf32_sh64_nbsd_bed

Definition at line 806 of file elf32-sh64.c.

#define elf32_bed   elf32_sh64_lin_bed

Definition at line 806 of file elf32-sh64.c.

Definition at line 86 of file elf32-sh64.c.

Definition at line 84 of file elf32-sh64.c.

Definition at line 90 of file elf32-sh64.c.

Definition at line 85 of file elf32-sh64.c.

Definition at line 87 of file elf32-sh64.c.

Definition at line 89 of file elf32-sh64.c.

Definition at line 93 of file elf32-sh64.c.

Definition at line 91 of file elf32-sh64.c.

Definition at line 83 of file elf32-sh64.c.

#define elf_backend_special_sections   sh64_elf_special_sections

Definition at line 92 of file elf32-sh64.c.

#define ELF_COMMONPAGESIZE   0x1000

Definition at line 808 of file elf32-sh64.c.

#define ELF_MAXPAGESIZE   0x10000

Definition at line 787 of file elf32-sh64.c.

#define elf_symbol_leading_char   0

Definition at line 790 of file elf32-sh64.c.

#define GOT_BIAS   (-((long)-32768))

Definition at line 108 of file elf32-sh64.c.

#define INCLUDE_SHMEDIA

Definition at line 109 of file elf32-sh64.c.

#define SH64_ELF

Definition at line 21 of file elf32-sh64.c.

Definition at line 76 of file elf32-sh64.c.

Definition at line 77 of file elf32-sh64.c.

Definition at line 81 of file elf32-sh64.c.

Definition at line 78 of file elf32-sh64.c.

Definition at line 110 of file elf32-sh64.c.

#define TARGET_BIG_NAME   "elf32-sh64"

Definition at line 800 of file elf32-sh64.c.

#define TARGET_BIG_NAME   "elf32-sh64-nbsd"

Definition at line 800 of file elf32-sh64.c.

#define TARGET_BIG_NAME   "elf32-sh64big-linux"

Definition at line 800 of file elf32-sh64.c.

Definition at line 798 of file elf32-sh64.c.

Definition at line 798 of file elf32-sh64.c.

Definition at line 798 of file elf32-sh64.c.

#define TARGET_LITTLE_NAME   "elf32-sh64l"

Definition at line 804 of file elf32-sh64.c.

#define TARGET_LITTLE_NAME   "elf32-sh64l-nbsd"

Definition at line 804 of file elf32-sh64.c.

#define TARGET_LITTLE_NAME   "elf32-sh64-linux"

Definition at line 804 of file elf32-sh64.c.

Definition at line 802 of file elf32-sh64.c.

Definition at line 802 of file elf32-sh64.c.

Definition at line 802 of file elf32-sh64.c.


Function Documentation

bfd_boolean sh64_backend_section_from_shdr ( bfd abfd,
Elf_Internal_Shdr hdr,
const char *  name,
int  shindex 
) [static]

Definition at line 265 of file elf32-sh64.c.

{
  flagword flags = 0;

  /* We do like MIPS with a bit switch for recognized types, and returning
     FALSE for a recognized section type with an unexpected name.  Right
     now we only have one recognized type, but that might change.  */
  switch (hdr->sh_type)
    {
    case SHT_SH5_CR_SORTED:
      if (strcmp (name, SH64_CRANGES_SECTION_NAME) != 0)
       return FALSE;

      /* We set the SEC_SORT_ENTRIES flag so it can be passed on to
        sh64_elf_fake_sections, keeping SHT_SH5_CR_SORTED if this object
        passes through objcopy.  Perhaps it is brittle; the flag can
        suddenly be used by other BFD parts, but it seems not really used
        anywhere at the moment.  */
      flags = SEC_DEBUGGING | SEC_SORT_ENTRIES;
      break;

    default:
      return FALSE;
    }

  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
    return FALSE;

  if (flags
      && ! bfd_set_section_flags (abfd, hdr->bfd_section,
                              bfd_get_section_flags (abfd,
                                                  hdr->bfd_section)
                              | flags))
    return FALSE;

  return TRUE;
}

Here is the call graph for this function:

bfd_boolean sh64_bfd_elf_copy_private_section_data ( bfd ibfd,
asection isec,
bfd obfd,
asection osec 
) [static]

Definition at line 310 of file elf32-sh64.c.

{
  struct sh64_section_data *sh64_sec_data;

  if (ibfd->xvec->flavour != bfd_target_elf_flavour
      || obfd->xvec->flavour != bfd_target_elf_flavour)
    return TRUE;

  if (! _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec))
    return FALSE;

  sh64_sec_data = sh64_elf_section_data (isec)->sh64_info;
  if (sh64_sec_data == NULL)
    {
      sh64_sec_data = bfd_zmalloc (sizeof (struct sh64_section_data));

      if (sh64_sec_data == NULL)
       return FALSE;

      sh64_sec_data->contents_flags
       = (elf_section_data (isec)->this_hdr.sh_flags
          & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));

      sh64_elf_section_data (osec)->sh64_info = sh64_sec_data;
    }

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean sh64_elf_add_symbol_hook ( bfd ,
struct bfd_link_info ,
Elf_Internal_Sym *  ,
const char **  ,
flagword ,
asection **  ,
bfd_vma  
) [static]
static bfd_boolean sh64_elf_add_symbol_hook ( bfd abfd,
struct bfd_link_info info,
Elf_Internal_Sym *  sym,
const char **  namep,
flagword *flagsp  ATTRIBUTE_UNUSED,
asection **  secp,
bfd_vma valp 
) [static]

Definition at line 383 of file elf32-sh64.c.

{
  /* We want to do this for relocatable as well as final linking.  */
  if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
      && is_elf_hash_table (info->hash))
    {
      struct elf_link_hash_entry *h;

      /* For relocatable links, we register the DataLabel sym in its own
        right, and tweak the name when it's output.  Otherwise, we make
        an indirect symbol of it.  */
      flagword flags
       = info->relocatable || info->emitrelocations
       ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;

      char *dl_name
       = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
      struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);

      BFD_ASSERT (sym_hash != NULL);

      /* Allocation may fail.  */
      if (dl_name == NULL)
       return FALSE;

      strcpy (dl_name, *namep);
      strcat (dl_name, DATALABEL_SUFFIX);

      h = (struct elf_link_hash_entry *)
       bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);

      if (h == NULL)
       {
         /* No previous datalabel symbol.  Make one.  */
         struct bfd_link_hash_entry *bh = NULL;
         const struct elf_backend_data *bed = get_elf_backend_data (abfd);

         if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
                                            flags, *secp, *valp,
                                            *namep, FALSE,
                                            bed->collect, &bh))
           {
             free (dl_name);
             return FALSE;
           }

         h = (struct elf_link_hash_entry *) bh;
         h->non_elf = 0;
         h->type = STT_DATALABEL;
       }
      else
       /* If a new symbol was created, it holds the allocated name.
          Otherwise, we don't need it anymore and should deallocate it.  */
       free (dl_name);

      if (h->type != STT_DATALABEL
         || ((info->relocatable || info->emitrelocations)
             && h->root.type != bfd_link_hash_undefined)
         || (! info->relocatable && !info->emitrelocations
             && h->root.type != bfd_link_hash_indirect))
       {
         /* Make sure we don't get confused on invalid input.  */
         (*_bfd_error_handler)
           (_("%s: encountered datalabel symbol in input"),
            bfd_get_filename (abfd));
         bfd_set_error (bfd_error_bad_value);
         return FALSE;
       }

      /* Now find the hash-table slot for this entry and fill it in.  */
      while (*sym_hash != NULL)
       sym_hash++;
      *sym_hash = h;

      /* Signal to caller to skip this symbol - we've handled it.  */
      *namep = NULL;
    }

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean sh64_elf_copy_private_data ( bfd ibfd,
bfd obfd 
) [static]

Definition at line 189 of file elf32-sh64.c.

{
  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
    return TRUE;

  BFD_ASSERT (!elf_flags_init (obfd)
             || (elf_elfheader (obfd)->e_flags
                == elf_elfheader (ibfd)->e_flags));

  elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
  return TRUE;
}
static bfd_boolean sh64_elf_fake_sections ( bfd ,
Elf_Internal_Shdr ,
asection  
) [static]
bfd_boolean sh64_elf_fake_sections ( bfd *output_bfd  ATTRIBUTE_UNUSED,
Elf_Internal_Shdr elf_section_hdr,
asection asect 
)

Definition at line 136 of file elf32-sh64.c.

{
  if (sh64_elf_section_data (asect)->sh64_info != NULL)
    elf_section_hdr->sh_flags
      |= sh64_elf_section_data (asect)->sh64_info->contents_flags;

  /* If this section has the SEC_SORT_ENTRIES flag set, it is a sorted
     .cranges section passing through objcopy.  */
  if ((bfd_get_section_flags (output_bfd, asect) & SEC_SORT_ENTRIES) != 0
      && strcmp (bfd_get_section_name (output_bfd, asect),
               SH64_CRANGES_SECTION_NAME) == 0)
    elf_section_hdr->sh_type = SHT_SH5_CR_SORTED;

  return TRUE;
}

Here is the call graph for this function:

static void sh64_elf_final_write_processing ( bfd ,
bfd_boolean   
) [static]
static void sh64_elf_final_write_processing ( bfd abfd,
bfd_boolean linker  ATTRIBUTE_UNUSED 
) [static]

Definition at line 643 of file elf32-sh64.c.

{
  bfd_vma ld_generated_cranges_size;
  asection *cranges
    = bfd_get_section_by_name (abfd, SH64_CRANGES_SECTION_NAME);

  /* If no new .cranges were added, the generic ELF linker parts will
     write it all out.  If not, we need to write them out when doing
     partial linking.  For a final link, we will sort them and write them
     all out further below.  */
  if (linker
      && cranges != NULL
      && elf_elfheader (abfd)->e_type != ET_EXEC
      && (ld_generated_cranges_size
         = sh64_elf_section_data (cranges)->sh64_info->cranges_growth) != 0)
    {
      bfd_vma incoming_cranges_size
       = cranges->size - ld_generated_cranges_size;

      if (! bfd_set_section_contents (abfd, cranges,
                                  cranges->contents
                                  + incoming_cranges_size,
                                  cranges->output_offset
                                  + incoming_cranges_size,
                                  ld_generated_cranges_size))
       {
         bfd_set_error (bfd_error_file_truncated);
         (*_bfd_error_handler)
           (_("%s: could not write out added .cranges entries"),
            bfd_get_filename (abfd));
       }
    }

  /* Only set entry address bit 0 and sort .cranges when linking to an
     executable; never with objcopy or strip.  */
  if (linker && elf_elfheader (abfd)->e_type == ET_EXEC)
    {
      struct sh64_find_section_vma_data fsec_data;
      sh64_elf_crange dummy;

      /* For a final link, set the low bit of the entry address to
        reflect whether or not it is a SHmedia address.
        FIXME: Perhaps we shouldn't do this if the entry address was
        supplied numerically, but we currently lack the infrastructure to
        recognize that: The entry symbol, and info whether it is numeric
        or a symbol name is kept private in the linker.  */
      fsec_data.addr = elf_elfheader (abfd)->e_entry;
      fsec_data.section = NULL;

      bfd_map_over_sections (abfd, sh64_find_section_for_address,
                          &fsec_data);
      if (fsec_data.section
         && (sh64_get_contents_type (fsec_data.section,
                                  elf_elfheader (abfd)->e_entry,
                                  &dummy) == CRT_SH5_ISA32))
       elf_elfheader (abfd)->e_entry |= 1;

      /* If we have a .cranges section, sort the entries.  */
      if (cranges != NULL)
       {
         bfd_size_type cranges_size = cranges->size;

         /* We know we always have these in memory at this time.  */
         BFD_ASSERT (cranges->contents != NULL);

         /* The .cranges may already have been sorted in the process of
            finding out the ISA-type of the entry address.  If not, we do
            it here.  */
         if (elf_section_data (cranges)->this_hdr.sh_type
             != SHT_SH5_CR_SORTED)
           {
             qsort (cranges->contents, cranges_size / SH64_CRANGE_SIZE,
                   SH64_CRANGE_SIZE,
                   bfd_big_endian (cranges->owner)
                   ? _bfd_sh64_crange_qsort_cmpb
                   : _bfd_sh64_crange_qsort_cmpl);
             elf_section_data (cranges)->this_hdr.sh_type
              = SHT_SH5_CR_SORTED;
           }

         /* We need to write it out in whole as sorted.  */
         if (! bfd_set_section_contents (abfd, cranges,
                                     cranges->contents,
                                     cranges->output_offset,
                                     cranges_size))
           {
             bfd_set_error (bfd_error_file_truncated);
             (*_bfd_error_handler)
              (_("%s: could not write out sorted .cranges entries"),
               bfd_get_filename (abfd));
           }
       }
    }
}

Here is the call graph for this function:

static int sh64_elf_get_symbol_type ( Elf_Internal_Sym *  elf_sym,
int  type 
) [static]

Definition at line 356 of file elf32-sh64.c.

{
  if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
    return STT_DATALABEL;

  return type;
}
static bfd_boolean sh64_elf_link_output_symbol_hook ( struct bfd_link_info ,
const char *  ,
Elf_Internal_Sym *  ,
asection ,
struct elf_link_hash_entry  
) [static]
bfd_boolean sh64_elf_link_output_symbol_hook ( struct bfd_link_info info,
const char *  cname,
Elf_Internal_Sym *  sym,
asection *input_sec  ATTRIBUTE_UNUSED,
struct elf_link_hash_entry *h  ATTRIBUTE_UNUSED 
)

Definition at line 480 of file elf32-sh64.c.

{
  char *name = (char *) cname;

  if (info->relocatable || info->emitrelocations)
    {
      if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
       name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
    }

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean sh64_elf_merge_private_data ( bfd ibfd,
bfd obfd 
) [static]

Definition at line 204 of file elf32-sh64.c.

{
  flagword old_flags, new_flags;

  if (! _bfd_generic_verify_endian_match (ibfd, obfd))
    return FALSE;

  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
    return TRUE;

  if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
    {
      const char *msg;

      if (bfd_get_arch_size (ibfd) == 32
         && bfd_get_arch_size (obfd) == 64)
       msg = _("%s: compiled as 32-bit object and %s is 64-bit");
      else if (bfd_get_arch_size (ibfd) == 64
              && bfd_get_arch_size (obfd) == 32)
       msg = _("%s: compiled as 64-bit object and %s is 32-bit");
      else
       msg = _("%s: object size does not match that of target %s");

      (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
                          bfd_get_filename (obfd));
      bfd_set_error (bfd_error_wrong_format);
      return FALSE;
    }

  old_flags = elf_elfheader (obfd)->e_flags;
  new_flags = elf_elfheader (ibfd)->e_flags;
  if (! elf_flags_init (obfd))
    {
      /* This happens when ld starts out with a 'blank' output file.  */
      elf_flags_init (obfd) = TRUE;
      elf_elfheader (obfd)->e_flags = old_flags = new_flags;
    }
  /* We don't allow linking in non-SH64 code.  */
  else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
    {
      (*_bfd_error_handler)
       ("%s: uses non-SH64 instructions while previous modules use SH64 instructions",
        bfd_get_filename (ibfd));
      bfd_set_error (bfd_error_bad_value);
      return FALSE;
    }

  /* I can't think of anything sane other than old_flags being EF_SH5 and
     that we need to preserve that.  */
  elf_elfheader (obfd)->e_flags = old_flags;
  return sh64_elf_set_mach_from_flags (obfd);
}

Here is the call graph for this function:

static void sh64_elf_merge_symbol_attribute ( struct elf_link_hash_entry h,
const Elf_Internal_Sym *  isym,
bfd_boolean  definition,
bfd_boolean dynamic  ATTRIBUTE_UNUSED 
) [static]

Definition at line 742 of file elf32-sh64.c.

{
  if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
    {
      unsigned char other;

      /* Take the balance of OTHER from the definition.  */
      other = (definition ? isym->st_other : h->other);
      other &= ~ ELF_ST_VISIBILITY (-1);
      h->other = other | ELF_ST_VISIBILITY (h->other);
    }

  return;
}
static bfd_boolean sh64_elf_new_section_hook ( bfd abfd,
asection sec 
) [static]

Definition at line 116 of file elf32-sh64.c.

{
  if (!sec->used_by_bfd)
    {
      struct _sh64_elf_section_data *sdata;
      bfd_size_type amt = sizeof (*sdata);

      sdata = bfd_zalloc (abfd, amt);
      if (sdata == NULL)
       return FALSE;
      sec->used_by_bfd = sdata;
    }

  return _bfd_elf_new_section_hook (abfd, sec);
}

Here is the call graph for this function:

static bfd_boolean sh64_elf_section_flags ( flagword flags,
const Elf_Internal_Shdr hdr 
) [static]

Definition at line 176 of file elf32-sh64.c.

{
  if (hdr->bfd_section == NULL)
    return FALSE;

  if (strcmp (hdr->bfd_section->name, SH64_CRANGES_SECTION_NAME) == 0)
    *flags |= SEC_DEBUGGING;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean sh64_elf_set_mach_from_flags ( bfd abfd) [static]

Definition at line 155 of file elf32-sh64.c.

{
  flagword flags = elf_elfheader (abfd)->e_flags;

  switch (flags & EF_SH_MACH_MASK)
    {
    case EF_SH5:
      /* These are fit to execute on SH5.  Just one but keep the switch
        construct to make additions easy.  */
      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
      break;

    default:
      bfd_set_error (bfd_error_wrong_format);
      return FALSE;
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean sh64_elf_set_private_flags ( bfd abfd,
flagword  flags 
) [static]

Definition at line 343 of file elf32-sh64.c.

{
  BFD_ASSERT (! elf_flags_init (abfd)
             || elf_elfheader (abfd)->e_flags == flags);

  elf_elfheader (abfd)->e_flags = flags;
  elf_flags_init (abfd) = TRUE;
  return sh64_elf_set_mach_from_flags (abfd);
}

Here is the call graph for this function:

static void sh64_find_section_for_address ( bfd ,
asection ,
void *   
) [static]

Here is the caller graph for this function:

static void sh64_find_section_for_address ( bfd *abfd  ATTRIBUTE_UNUSED,
asection section,
void *  data 
) [static]

Definition at line 609 of file elf32-sh64.c.

{
  bfd_vma vma;
  bfd_size_type size;

  struct sh64_find_section_vma_data *fsec_datap
    = (struct sh64_find_section_vma_data *) data;

  /* Return if already found.  */
  if (fsec_datap->section)
    return;

  /* If this section isn't part of the addressable contents, skip it.  */
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
    return;

  vma = bfd_get_section_vma (abfd, section);
  if (fsec_datap->addr < vma)
    return;

  size = section->size;
  if (fsec_datap->addr >= vma + size)
    return;

  fsec_datap->section = section;
}
static bfd_boolean shmedia_prepare_reloc ( struct bfd_link_info info,
bfd abfd,
asection input_section,
bfd_byte contents,
const Elf_Internal_Rela rel,
bfd_vma relocation 
) [static]

Definition at line 502 of file elf32-sh64.c.

{
  bfd_vma disp, dropped;

  switch (ELF32_R_TYPE (rel->r_info))
    {
    case R_SH_PT_16:
      /* Check the lowest bit of the destination field.  If it is 1, we
        check the ISA type of the destination (i.e. the low bit of the
        "relocation" value, and emit an error if the instruction does not
        match).  If it is 0, we change a PTA to PTB.  There should never
        be a PTB that should change to a PTA; that indicates a toolchain
        error; a mismatch with GAS.  */
      {
       char *msg = NULL;
       bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset);

       if (insn & (1 << 10))
         {
           /* Check matching insn and ISA (address of target).  */
           if ((insn & SHMEDIA_PTB_BIT) != 0
              && ((*relocation + rel->r_addend) & 1) != 0)
             msg = _("PTB mismatch: a SHmedia address (bit 0 == 1)");
           else if ((insn & SHMEDIA_PTB_BIT) == 0
                   && ((*relocation + rel->r_addend) & 1) == 0)
             msg = _("PTA mismatch: a SHcompact address (bit 0 == 0)");

           if (msg != NULL
              && ! ((*info->callbacks->reloc_dangerous)
                    (info, msg, abfd, input_section,
                     rel->r_offset)))
             return FALSE;
         }
       else
         {
           /* We shouldn't get here with a PTB insn and a R_SH_PT_16.  It
              means GAS output does not match expectations; a PTA or PTB
              expressed as such (or a PT found at assembly to be PTB)
              would match the test above, and PT expansion with an
              unknown destination (or when relaxing) will get us here.  */
           if ((insn & SHMEDIA_PTB_BIT) != 0)
             {
              (*_bfd_error_handler)
                (_("%s: GAS error: unexpected PTB insn with R_SH_PT_16"),
                 bfd_get_filename (input_section->owner));
              return FALSE;
             }

           /* Change the PTA to a PTB, if destination indicates so.  */
           if (((*relocation + rel->r_addend) & 1) == 0)
             bfd_put_32 (abfd, insn | SHMEDIA_PTB_BIT,
                       contents + rel->r_offset);
         }
      }

    case R_SH_SHMEDIA_CODE:
    case R_SH_DIR5U:
    case R_SH_DIR6S:
    case R_SH_DIR6U:
    case R_SH_DIR10S:
    case R_SH_DIR10SW:
    case R_SH_DIR10SL:
    case R_SH_DIR10SQ:
    case R_SH_IMMS16:
    case R_SH_IMMU16:
    case R_SH_IMM_LOW16:
    case R_SH_IMM_LOW16_PCREL:
    case R_SH_IMM_MEDLOW16:
    case R_SH_IMM_MEDLOW16_PCREL:
    case R_SH_IMM_MEDHI16:
    case R_SH_IMM_MEDHI16_PCREL:
    case R_SH_IMM_HI16:
    case R_SH_IMM_HI16_PCREL:
    case R_SH_64:
    case R_SH_64_PCREL:
      break;

    default:
      return FALSE;
    }

  disp = (*relocation & 0xf);
  dropped = 0;
  switch (ELF32_R_TYPE (rel->r_info))
    {
    case R_SH_DIR10SW: dropped = disp & 1; break;
    case R_SH_DIR10SL: dropped = disp & 3; break;
    case R_SH_DIR10SQ: dropped = disp & 7; break;
    }
  if (dropped != 0)
    {
      (*_bfd_error_handler)
       (_("%B: error: unaligned relocation type %d at %08x reloc %p\n"),
        input_section->owner, ELF32_R_TYPE (rel->r_info),
        (unsigned) rel->r_offset, relocation);
      return FALSE;
    }

  return TRUE;
}

Here is the caller graph for this function:


Variable Documentation

Initial value:
{
  { STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 },
  { NULL,                       0, 0, 0,            0 }
}

Definition at line 760 of file elf32-sh64.c.