Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Functions | Variables
elf64-mips.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "aout/ar.h"
#include "bfdlink.h"
#include "genlink.h"
#include "elf-bfd.h"
#include "elfxx-mips.h"
#include "elf/mips.h"
#include "coff/sym.h"
#include "coff/symconst.h"
#include "coff/internal.h"
#include "coff/ecoff.h"
#include "coff/alpha.h"
#include "ecoffswap.h"
#include "elf64-target.h"

Go to the source code of this file.

Classes

struct  elf_reloc_map

Defines

#define ECOFF_SIGNED_64
#define MINUS_ONE   (((bfd_vma)0) - 1)
#define MIPS_RESERVED_GOTNO   (2)
#define ELF_ARCH   bfd_arch_mips
#define ELF_MACHINE_CODE   EM_MIPS
#define elf_backend_collect   TRUE
#define elf_backend_type_change_ok   TRUE
#define elf_backend_can_gc_sections   TRUE
#define elf_info_to_howto   mips_elf64_info_to_howto_rela
#define elf_info_to_howto_rel   mips_elf64_info_to_howto_rel
#define elf_backend_object_p   mips_elf64_object_p
#define elf_backend_symbol_processing   _bfd_mips_elf_symbol_processing
#define elf_backend_section_processing   _bfd_mips_elf_section_processing
#define elf_backend_section_from_shdr   _bfd_mips_elf_section_from_shdr
#define elf_backend_fake_sections   _bfd_mips_elf_fake_sections
#define elf_backend_section_from_bfd_section   _bfd_mips_elf_section_from_bfd_section
#define elf_backend_add_symbol_hook   _bfd_mips_elf_add_symbol_hook
#define elf_backend_link_output_symbol_hook   _bfd_mips_elf_link_output_symbol_hook
#define elf_backend_create_dynamic_sections   _bfd_mips_elf_create_dynamic_sections
#define elf_backend_check_relocs   _bfd_mips_elf_check_relocs
#define elf_backend_merge_symbol_attribute   _bfd_mips_elf_merge_symbol_attribute
#define elf_backend_adjust_dynamic_symbol   _bfd_mips_elf_adjust_dynamic_symbol
#define elf_backend_always_size_sections   _bfd_mips_elf_always_size_sections
#define elf_backend_size_dynamic_sections   _bfd_mips_elf_size_dynamic_sections
#define elf_backend_init_index_section   _bfd_elf_init_1_index_section
#define elf_backend_relocate_section   _bfd_mips_elf_relocate_section
#define elf_backend_finish_dynamic_symbol   _bfd_mips_elf_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections   _bfd_mips_elf_finish_dynamic_sections
#define elf_backend_final_write_processing   _bfd_mips_elf_final_write_processing
#define elf_backend_additional_program_headers   _bfd_mips_elf_additional_program_headers
#define elf_backend_modify_segment_map   _bfd_mips_elf_modify_segment_map
#define elf_backend_gc_mark_hook   _bfd_mips_elf_gc_mark_hook
#define elf_backend_gc_sweep_hook   _bfd_mips_elf_gc_sweep_hook
#define elf_backend_copy_indirect_symbol   _bfd_mips_elf_copy_indirect_symbol
#define elf_backend_hide_symbol   _bfd_mips_elf_hide_symbol
#define elf_backend_ignore_discarded_relocs   _bfd_mips_elf_ignore_discarded_relocs
#define elf_backend_mips_irix_compat   elf64_mips_irix_compat
#define elf_backend_mips_rtype_to_howto   mips_elf64_rtype_to_howto
#define elf_backend_ecoff_debug_swap   &mips_elf64_ecoff_debug_swap
#define elf_backend_size_info   mips_elf64_size_info
#define elf_backend_grok_prstatus   elf64_mips_grok_prstatus
#define elf_backend_grok_psinfo   elf64_mips_grok_psinfo
#define elf_backend_got_header_size   (4 * MIPS_RESERVED_GOTNO)
#define elf_backend_may_use_rel_p   1
#define elf_backend_may_use_rela_p   1
#define elf_backend_default_use_rela_p   1
#define elf_backend_write_section   _bfd_mips_elf_write_section
#define bfd_elf64_find_nearest_line   _bfd_mips_elf_find_nearest_line
#define bfd_elf64_find_inliner_info   _bfd_mips_elf_find_inliner_info
#define bfd_elf64_new_section_hook   _bfd_mips_elf_new_section_hook
#define bfd_elf64_set_section_contents   _bfd_mips_elf_set_section_contents
#define bfd_elf64_bfd_get_relocated_section_contents   _bfd_elf_mips_get_relocated_section_contents
#define bfd_elf64_bfd_link_hash_table_create   _bfd_mips_elf_link_hash_table_create
#define bfd_elf64_bfd_final_link   _bfd_mips_elf_final_link
#define bfd_elf64_bfd_merge_private_bfd_data   _bfd_mips_elf_merge_private_bfd_data
#define bfd_elf64_bfd_set_private_flags   _bfd_mips_elf_set_private_flags
#define bfd_elf64_bfd_print_private_bfd_data   _bfd_mips_elf_print_private_bfd_data
#define bfd_elf64_get_reloc_upper_bound   mips_elf64_get_reloc_upper_bound
#define bfd_elf64_canonicalize_reloc   mips_elf64_canonicalize_reloc
#define bfd_elf64_get_dynamic_reloc_upper_bound   mips_elf64_get_dynamic_reloc_upper_bound
#define bfd_elf64_canonicalize_dynamic_reloc   mips_elf64_canonicalize_dynamic_reloc
#define bfd_elf64_bfd_relax_section   _bfd_mips_relax_section
#define bfd_elf64_archive_functions
#define bfd_elf64_archive_slurp_extended_name_table   _bfd_archive_coff_slurp_extended_name_table
#define bfd_elf64_archive_construct_extended_name_table   _bfd_archive_coff_construct_extended_name_table
#define bfd_elf64_archive_truncate_arname   _bfd_archive_coff_truncate_arname
#define bfd_elf64_archive_read_ar_hdr   _bfd_archive_coff_read_ar_hdr
#define bfd_elf64_archive_openr_next_archived_file   _bfd_archive_coff_openr_next_archived_file
#define bfd_elf64_archive_get_elt_at_index   _bfd_archive_coff_get_elt_at_index
#define bfd_elf64_archive_generic_stat_arch_elt   _bfd_archive_coff_generic_stat_arch_elt
#define bfd_elf64_archive_update_armap_timestamp   _bfd_archive_coff_update_armap_timestamp
#define TARGET_LITTLE_SYM   bfd_elf64_littlemips_vec
#define TARGET_LITTLE_NAME   "elf64-littlemips"
#define TARGET_BIG_SYM   bfd_elf64_bigmips_vec
#define TARGET_BIG_NAME   "elf64-bigmips"
#define ELF_MAXPAGESIZE   0x10000
#define ELF_COMMONPAGESIZE   0x1000
#define TARGET_LITTLE_SYM   bfd_elf64_tradlittlemips_vec
#define TARGET_LITTLE_NAME   "elf64-tradlittlemips"
#define TARGET_BIG_SYM   bfd_elf64_tradbigmips_vec
#define TARGET_BIG_NAME   "elf64-tradbigmips"
#define ELF_MAXPAGESIZE   0x10000
#define ELF_COMMONPAGESIZE   0x1000
#define elf64_bed   elf64_tradbed

Functions

static void mips_elf64_swap_reloc_in (bfd *, const Elf64_Mips_External_Rel *, Elf64_Mips_Internal_Rela *)
static void mips_elf64_swap_reloca_in (bfd *, const Elf64_Mips_External_Rela *, Elf64_Mips_Internal_Rela *)
static void mips_elf64_swap_reloc_out (bfd *, const Elf64_Mips_Internal_Rela *, Elf64_Mips_External_Rel *)
static void mips_elf64_swap_reloca_out (bfd *, const Elf64_Mips_Internal_Rela *, Elf64_Mips_External_Rela *)
static void mips_elf64_be_swap_reloc_in (bfd *, const bfd_byte *, Elf_Internal_Rela *)
static void mips_elf64_be_swap_reloc_out (bfd *, const Elf_Internal_Rela *, bfd_byte *)
static void mips_elf64_be_swap_reloca_in (bfd *, const bfd_byte *, Elf_Internal_Rela *)
static void mips_elf64_be_swap_reloca_out (bfd *, const Elf_Internal_Rela *, bfd_byte *)
static reloc_howto_type * bfd_elf64_bfd_reloc_type_lookup (bfd *, bfd_reloc_code_real_type)
static reloc_howto_type * mips_elf64_rtype_to_howto (unsigned int, bfd_boolean)
static void mips_elf64_info_to_howto_rel (bfd *, arelent *, Elf_Internal_Rela *)
static void mips_elf64_info_to_howto_rela (bfd *, arelent *, Elf_Internal_Rela *)
static long mips_elf64_get_reloc_upper_bound (bfd *, asection *)
static long mips_elf64_canonicalize_reloc (bfd *, asection *, arelent **, asymbol **)
static long mips_elf64_get_dynamic_reloc_upper_bound (bfd *)
static long mips_elf64_canonicalize_dynamic_reloc (bfd *, arelent **, asymbol **)
static bfd_boolean mips_elf64_slurp_one_reloc_table (bfd *, asection *, Elf_Internal_Shdr *, bfd_size_type, arelent *, asymbol **, bfd_boolean)
static bfd_boolean mips_elf64_slurp_reloc_table (bfd *, asection *, asymbol **, bfd_boolean)
static void mips_elf64_write_relocs (bfd *, asection *, void *)
static void mips_elf64_write_rel (bfd *, asection *, Elf_Internal_Shdr *, int *, void *)
static void mips_elf64_write_rela (bfd *, asection *, Elf_Internal_Shdr *, int *, void *)
static bfd_reloc_status_type mips_elf64_gprel16_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **)
static bfd_reloc_status_type mips_elf64_literal_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **)
static bfd_reloc_status_type mips_elf64_gprel32_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **)
static bfd_reloc_status_type mips_elf64_shift6_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **)
static bfd_reloc_status_type mips16_gprel_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **)
static bfd_boolean mips_elf64_assign_gp (bfd *, bfd_vma *)
static bfd_reloc_status_type mips_elf64_final_gp (bfd *, asymbol *, bfd_boolean, char **, bfd_vma *)
static bfd_boolean mips_elf64_object_p (bfd *)
static irix_compat_t elf64_mips_irix_compat (bfd *)
static bfd_boolean elf64_mips_grok_prstatus (bfd *, Elf_Internal_Note *)
static bfd_boolean elf64_mips_grok_psinfo (bfd *, Elf_Internal_Note *)
static reloc_howto_type * bfd_elf64_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
static reloc_howto_type * bfd_elf64_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
static void mips_elf64_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr ATTRIBUTE_UNUSED, Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
static void mips_elf64_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr ATTRIBUTE_UNUSED, Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
static long mips_elf64_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
static long mips_elf64_canonicalize_reloc (bfd *abfd, sec_ptr section, arelent **relptr, asymbol **symbols)
bfd_boolean bfd_elf64_archive_slurp_armap (bfd *)
bfd_boolean bfd_elf64_archive_write_armap (bfd *, unsigned int, struct orl *, unsigned int, int)

Variables

const bfd_target bfd_elf64_bigmips_vec
const bfd_target bfd_elf64_littlemips_vec
static reloc_howto_type mips_elf64_howto_table_rel []
static reloc_howto_type mips_elf64_howto_table_rela []
static reloc_howto_type mips16_elf64_howto_table_rel []
static reloc_howto_type mips16_elf64_howto_table_rela []
static reloc_howto_type elf_mips_gnu_vtinherit_howto
static reloc_howto_type elf_mips_gnu_vtentry_howto
static reloc_howto_type elf_mips_gnu_rel16_s2
static reloc_howto_type elf_mips_gnu_rela16_s2
static struct elf_reloc_map []
static struct ecoff_debug_swap

Class Documentation

struct elf_reloc_map

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

Class Members
bfd_reloc_code_real_type bfd_reloc_val
bfd_reloc_code_real_type bfd_val
unsigned char elf_reloc_val
int elf_reloc_val
unsigned char howto_index

Define Documentation

Definition at line 3168 of file elf64-mips.c.

Definition at line 3161 of file elf64-mips.c.

Definition at line 3177 of file elf64-mips.c.

Definition at line 3175 of file elf64-mips.c.

Definition at line 3173 of file elf64-mips.c.

Definition at line 3172 of file elf64-mips.c.

Definition at line 3166 of file elf64-mips.c.

Definition at line 3170 of file elf64-mips.c.

Definition at line 3179 of file elf64-mips.c.

Definition at line 3147 of file elf64-mips.c.

Definition at line 3143 of file elf64-mips.c.

Definition at line 3145 of file elf64-mips.c.

Definition at line 3148 of file elf64-mips.c.

Definition at line 3151 of file elf64-mips.c.

Definition at line 3158 of file elf64-mips.c.

Definition at line 3150 of file elf64-mips.c.

Definition at line 3157 of file elf64-mips.c.

Definition at line 3155 of file elf64-mips.c.

Definition at line 3140 of file elf64-mips.c.

Definition at line 3139 of file elf64-mips.c.

Definition at line 3156 of file elf64-mips.c.

Definition at line 3154 of file elf64-mips.c.

Definition at line 3141 of file elf64-mips.c.

Definition at line 3142 of file elf64-mips.c.

#define ECOFF_SIGNED_64

Definition at line 61 of file elf64-mips.c.

#define elf64_bed   elf64_tradbed

Definition at line 3209 of file elf64-mips.c.

#define ELF_ARCH   bfd_arch_mips

Definition at line 3071 of file elf64-mips.c.

Definition at line 3086 of file elf64-mips.c.

Definition at line 3108 of file elf64-mips.c.

Definition at line 3094 of file elf64-mips.c.

Definition at line 3096 of file elf64-mips.c.

Definition at line 3076 of file elf64-mips.c.

Definition at line 3091 of file elf64-mips.c.

#define elf_backend_collect   TRUE

Definition at line 3074 of file elf64-mips.c.

Definition at line 3113 of file elf64-mips.c.

Definition at line 3089 of file elf64-mips.c.

Definition at line 3132 of file elf64-mips.c.

#define elf_backend_ecoff_debug_swap   &mips_elf64_ecoff_debug_swap

Definition at line 3120 of file elf64-mips.c.

Definition at line 3083 of file elf64-mips.c.

Definition at line 3106 of file elf64-mips.c.

Definition at line 3104 of file elf64-mips.c.

Definition at line 3102 of file elf64-mips.c.

Definition at line 3111 of file elf64-mips.c.

Definition at line 3112 of file elf64-mips.c.

Definition at line 3126 of file elf64-mips.c.

Definition at line 3123 of file elf64-mips.c.

Definition at line 3124 of file elf64-mips.c.

Definition at line 3115 of file elf64-mips.c.

Definition at line 3116 of file elf64-mips.c.

Definition at line 3100 of file elf64-mips.c.

Definition at line 3087 of file elf64-mips.c.

#define elf_backend_may_use_rel_p   1

Definition at line 3130 of file elf64-mips.c.

Definition at line 3131 of file elf64-mips.c.

Definition at line 3092 of file elf64-mips.c.

Definition at line 3118 of file elf64-mips.c.

Definition at line 3119 of file elf64-mips.c.

Definition at line 3110 of file elf64-mips.c.

Definition at line 3079 of file elf64-mips.c.

Definition at line 3101 of file elf64-mips.c.

Definition at line 3084 of file elf64-mips.c.

Definition at line 3082 of file elf64-mips.c.

Definition at line 3081 of file elf64-mips.c.

Definition at line 3098 of file elf64-mips.c.

#define elf_backend_size_info   mips_elf64_size_info

Definition at line 3121 of file elf64-mips.c.

Definition at line 3080 of file elf64-mips.c.

Definition at line 3075 of file elf64-mips.c.

Definition at line 3134 of file elf64-mips.c.

#define ELF_COMMONPAGESIZE   0x1000

Definition at line 3208 of file elf64-mips.c.

#define ELF_COMMONPAGESIZE   0x1000

Definition at line 3208 of file elf64-mips.c.

Definition at line 3077 of file elf64-mips.c.

Definition at line 3078 of file elf64-mips.c.

#define ELF_MACHINE_CODE   EM_MIPS

Definition at line 3072 of file elf64-mips.c.

#define ELF_MAXPAGESIZE   0x10000

Definition at line 3207 of file elf64-mips.c.

#define ELF_MAXPAGESIZE   0x10000

Definition at line 3207 of file elf64-mips.c.

#define MINUS_ONE   (((bfd_vma)0) - 1)

Definition at line 135 of file elf64-mips.c.

#define MIPS_RESERVED_GOTNO   (2)

Definition at line 138 of file elf64-mips.c.

#define TARGET_BIG_NAME   "elf64-bigmips"

Definition at line 3205 of file elf64-mips.c.

#define TARGET_BIG_NAME   "elf64-tradbigmips"

Definition at line 3205 of file elf64-mips.c.

Definition at line 3204 of file elf64-mips.c.

Definition at line 3204 of file elf64-mips.c.

#define TARGET_LITTLE_NAME   "elf64-littlemips"

Definition at line 3203 of file elf64-mips.c.

#define TARGET_LITTLE_NAME   "elf64-tradlittlemips"

Definition at line 3203 of file elf64-mips.c.

Definition at line 3202 of file elf64-mips.c.

Definition at line 3202 of file elf64-mips.c.


Function Documentation

Definition at line 41 of file archive64.c.

{
  struct artdata *ardata = bfd_ardata (abfd);
  char nextname[17];
  file_ptr arhdrpos;
  bfd_size_type i, parsed_size, nsymz, stringsize, carsym_size, ptrsize;
  struct areltdata *mapdata;
  bfd_byte int_buf[8];
  char *stringbase;
  bfd_byte *raw_armap = NULL;
  carsym *carsyms;
  bfd_size_type amt;

  ardata->symdefs = NULL;

  /* Get the name of the first element.  */
  arhdrpos = bfd_tell (abfd);
  i = bfd_bread (nextname, 16, abfd);
  if (i == 0)
    return TRUE;
  if (i != 16)
    return FALSE;

  if (bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR) != 0)
    return FALSE;

  /* Archives with traditional armaps are still permitted.  */
  if (CONST_STRNEQ (nextname, "/               "))
    return bfd_slurp_armap (abfd);

  if (! CONST_STRNEQ (nextname, "/SYM64/         "))
    {
      bfd_has_map (abfd) = FALSE;
      return TRUE;
    }

  mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
  if (mapdata == NULL)
    return FALSE;
  parsed_size = mapdata->parsed_size;
  bfd_release (abfd, mapdata);

  if (bfd_bread (int_buf, 8, abfd) != 8)
    {
      if (bfd_get_error () != bfd_error_system_call)
       bfd_set_error (bfd_error_malformed_archive);
      return FALSE;
    }

  nsymz = bfd_getb64 (int_buf);
  stringsize = parsed_size - 8 * nsymz - 8;

  carsym_size = nsymz * sizeof (carsym);
  ptrsize = 8 * nsymz;

  amt = carsym_size + stringsize + 1;
  ardata->symdefs = bfd_zalloc (abfd, amt);
  if (ardata->symdefs == NULL)
    return FALSE;
  carsyms = ardata->symdefs;
  stringbase = ((char *) ardata->symdefs) + carsym_size;

  raw_armap = bfd_alloc (abfd, ptrsize);
  if (raw_armap == NULL)
    goto release_symdefs;

  if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
      || bfd_bread (stringbase, stringsize, abfd) != stringsize)
    {
      if (bfd_get_error () != bfd_error_system_call)
       bfd_set_error (bfd_error_malformed_archive);
      goto release_raw_armap;
    }

  for (i = 0; i < nsymz; i++)
    {
      carsyms->file_offset = bfd_getb64 (raw_armap + i * 8);
      carsyms->name = stringbase;
      stringbase += strlen (stringbase) + 1;
      ++carsyms;
    }
  *stringbase = '\0';

  ardata->symdef_count = nsymz;
  ardata->first_file_filepos = bfd_tell (abfd);
  /* Pad to an even boundary if you have to.  */
  ardata->first_file_filepos += (ardata->first_file_filepos) % 2;

  bfd_has_map (abfd) = TRUE;
  bfd_release (abfd, raw_armap);

  return TRUE;

release_raw_armap:
  bfd_release (abfd, raw_armap);
release_symdefs:
  bfd_release (abfd, ardata->symdefs);
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 146 of file archive64.c.

{
  unsigned int ranlibsize = (symbol_count * 8) + 8;
  unsigned int stringsize = stridx;
  unsigned int mapsize = stringsize + ranlibsize;
  file_ptr archive_member_file_ptr;
  bfd *current = arch->archive_head;
  unsigned int count;
  struct ar_hdr hdr;
  int padding;
  bfd_byte buf[8];

  padding = BFD_ALIGN (mapsize, 8) - mapsize;
  mapsize += padding;

  /* work out where the first object file will go in the archive */
  archive_member_file_ptr = (mapsize
                          + elength
                          + sizeof (struct ar_hdr)
                          + SARMAG);

  memset (&hdr, ' ', sizeof (struct ar_hdr));
  memcpy (hdr.ar_name, "/SYM64/", strlen ("/SYM64/"));
  _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
                    mapsize);
  _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
                    time (NULL));
  /* This, at least, is what Intel coff sets the values to.: */
  _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
  _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
  _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
  memcpy (hdr.ar_fmag, ARFMAG, 2);

  /* Write the ar header for this item and the number of symbols */

  if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
      != sizeof (struct ar_hdr))
    return FALSE;

  bfd_putb64 ((bfd_vma) symbol_count, buf);
  if (bfd_bwrite (buf, 8, arch) != 8)
    return FALSE;

  /* Two passes, first write the file offsets for each symbol -
     remembering that each offset is on a two byte boundary.  */

  /* Write out the file offset for the file associated with each
     symbol, and remember to keep the offsets padded out.  */

  current = arch->archive_head;
  count = 0;
  while (current != NULL && count < symbol_count)
    {
      /* For each symbol which is used defined in this object, write out
        the object file's address in the archive */

      while (map[count].u.abfd == current)
       {
         bfd_putb64 ((bfd_vma) archive_member_file_ptr, buf);
         if (bfd_bwrite (buf, 8, arch) != 8)
           return FALSE;
         count++;
       }
      /* Add size of this archive entry */
      archive_member_file_ptr += (arelt_size (current)
                              + sizeof (struct ar_hdr));
      /* remember about the even alignment */
      archive_member_file_ptr += archive_member_file_ptr % 2;
      current = current->next;
    }

  /* now write the strings themselves */
  for (count = 0; count < symbol_count; count++)
    {
      size_t len = strlen (*map[count].name) + 1;

      if (bfd_bwrite (*map[count].name, len, arch) != len)
       return FALSE;
    }

  /* The spec says that this should be padded to an 8 byte boundary.
     However, the Irix 6.2 tools do not appear to do this.  */
  while (padding != 0)
    {
      if (bfd_bwrite ("", 1, arch) != 1)
       return FALSE;
      --padding;
    }

  return TRUE;
}

Here is the call graph for this function:

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

Definition at line 2228 of file elf64-mips.c.

{
  unsigned int i;

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

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

  if (strcasecmp (elf_mips_gnu_vtinherit_howto.name, r_name) == 0)
    return &elf_mips_gnu_vtinherit_howto;
  if (strcasecmp (elf_mips_gnu_vtentry_howto.name, r_name) == 0)
    return &elf_mips_gnu_vtentry_howto;
  if (strcasecmp (elf_mips_gnu_rel16_s2.name, r_name) == 0)
    return &elf_mips_gnu_rel16_s2;
  if (strcasecmp (elf_mips_gnu_rela16_s2.name, r_name) == 0)
    return &elf_mips_gnu_rela16_s2;

  return NULL;
}

Here is the call graph for this function:

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

Definition at line 2192 of file elf64-mips.c.

{
  unsigned int i;
  /* FIXME: We default to RELA here instead of choosing the right
     relocation variant.  */
  reloc_howto_type *howto_table = mips_elf64_howto_table_rela;
  reloc_howto_type *howto16_table = mips16_elf64_howto_table_rela;

  for (i = 0; i < sizeof (mips_reloc_map) / sizeof (struct elf_reloc_map);
       i++)
    {
      if (mips_reloc_map[i].bfd_val == code)
       return &howto_table[(int) mips_reloc_map[i].elf_val];
    }

  for (i = 0; i < sizeof (mips16_reloc_map) / sizeof (struct elf_reloc_map);
       i++)
    {
      if (mips16_reloc_map[i].bfd_val == code)
       return &howto16_table[(int) mips16_reloc_map[i].elf_val];
    }

  switch (code)
    {
    case BFD_RELOC_VTABLE_INHERIT:
      return &elf_mips_gnu_vtinherit_howto;
    case BFD_RELOC_VTABLE_ENTRY:
      return &elf_mips_gnu_vtentry_howto;
    default:
      bfd_set_error (bfd_error_bad_value);
      return NULL;
    }
}

Here is the call graph for this function:

static bfd_boolean elf64_mips_grok_prstatus ( bfd abfd,
Elf_Internal_Note note 
) [static]

Definition at line 2934 of file elf64-mips.c.

{
  int offset;
  unsigned int size;

  switch (note->descsz)
    {
      default:
       return FALSE;

      case 480:             /* Linux/MIPS - N64 kernel */
       /* pr_cursig */
       elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);

       /* pr_pid */
       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);

       /* pr_reg */
       offset = 112;
       size = 360;

       break;
    }

  /* Make a ".reg/999" section.  */
  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
                                     size, note->descpos + offset);
}

Here is the call graph for this function:

static bfd_boolean elf64_mips_grok_psinfo ( bfd abfd,
Elf_Internal_Note note 
) [static]

Definition at line 2964 of file elf64-mips.c.

{
  switch (note->descsz)
    {
      default:
       return FALSE;

      case 136:             /* Linux/MIPS - N64 kernel elf_prpsinfo */
       elf_tdata (abfd)->core_program
        = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
       elf_tdata (abfd)->core_command
        = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
    }

  /* Note that for some reason, a spurious space is tacked
     onto the end of the args in some (at least one anyway)
     implementations, so strip it off if it exists.  */

  {
    char *command = elf_tdata (abfd)->core_command;
    int n = strlen (command);

    if (0 < n && command[n - 1] == ' ')
      command[n - 1] = '\0';
  }

  return TRUE;
}

Here is the call graph for this function:

static irix_compat_t elf64_mips_irix_compat ( bfd abfd) [static]

Definition at line 2923 of file elf64-mips.c.

{
  if ((abfd->xvec == &bfd_elf64_bigmips_vec)
      || (abfd->xvec == &bfd_elf64_littlemips_vec))
    return ict_irix6;
  else
    return ict_none;
}

Here is the caller graph for this function:

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

Definition at line 2078 of file elf64-mips.c.

{
  bfd_boolean relocatable;
  bfd_reloc_status_type ret;
  bfd_byte *location;
  bfd_vma gp;

  /* If we're relocating, and this is an external symbol, we don't want
     to change anything.  */
  if (output_bfd != NULL
      && (symbol->flags & BSF_SECTION_SYM) == 0
      && (symbol->flags & BSF_LOCAL) != 0)
    {
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }

  if (output_bfd != NULL)
    relocatable = TRUE;
  else
    {
      relocatable = FALSE;
      output_bfd = symbol->section->output_section->owner;
    }

  ret = mips_elf64_final_gp (output_bfd, symbol, relocatable, error_message,
                          &gp);
  if (ret != bfd_reloc_ok)
    return ret;

  location = (bfd_byte *) data + reloc_entry->address;
  _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
                               location);
  ret = _bfd_mips_elf_gprel16_with_gp (abfd, symbol, reloc_entry,
                                   input_section, relocatable,
                                   data, gp);
  _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, !relocatable,
                             location);

  return ret;
}

Here is the call graph for this function:

static bfd_boolean mips_elf64_assign_gp ( bfd output_bfd,
bfd_vma pgp 
) [static]

Definition at line 1820 of file elf64-mips.c.

{
  unsigned int count;
  asymbol **sym;
  unsigned int i;

  /* If we've already figured out what GP will be, just return it.  */
  *pgp = _bfd_get_gp_value (output_bfd);
  if (*pgp)
    return TRUE;

  count = bfd_get_symcount (output_bfd);
  sym = bfd_get_outsymbols (output_bfd);

  /* The linker script will have created a symbol named `_gp' with the
     appropriate value.  */
  if (sym == NULL)
    i = count;
  else
    {
      for (i = 0; i < count; i++, sym++)
       {
         register const char *name;

         name = bfd_asymbol_name (*sym);
         if (*name == '_' && strcmp (name, "_gp") == 0)
           {
             *pgp = bfd_asymbol_value (*sym);
             _bfd_set_gp_value (output_bfd, *pgp);
             break;
           }
       }
    }

  if (i >= count)
    {
      /* Only get the error once.  */
      *pgp = 4;
      _bfd_set_gp_value (output_bfd, *pgp);
      return FALSE;
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mips_elf64_be_swap_reloc_in ( bfd abfd,
const bfd_byte src,
Elf_Internal_Rela dst 
) [static]

Definition at line 1726 of file elf64-mips.c.

{
  Elf64_Mips_Internal_Rela mirel;

  mips_elf64_swap_reloc_in (abfd,
                         (const Elf64_Mips_External_Rel *) src,
                         &mirel);

  dst[0].r_offset = mirel.r_offset;
  dst[0].r_info = ELF64_R_INFO (mirel.r_sym, mirel.r_type);
  dst[0].r_addend = 0;
  dst[1].r_offset = mirel.r_offset;
  dst[1].r_info = ELF64_R_INFO (mirel.r_ssym, mirel.r_type2);
  dst[1].r_addend = 0;
  dst[2].r_offset = mirel.r_offset;
  dst[2].r_info = ELF64_R_INFO (STN_UNDEF, mirel.r_type3);
  dst[2].r_addend = 0;
}

Here is the call graph for this function:

static void mips_elf64_be_swap_reloc_out ( bfd abfd,
const Elf_Internal_Rela src,
bfd_byte dst 
) [static]

Definition at line 1772 of file elf64-mips.c.

{
  Elf64_Mips_Internal_Rela mirel;

  mirel.r_offset = src[0].r_offset;
  BFD_ASSERT(src[0].r_offset == src[1].r_offset);

  mirel.r_type = ELF64_MIPS_R_TYPE (src[0].r_info);
  mirel.r_sym = ELF64_R_SYM (src[0].r_info);
  mirel.r_type2 = ELF64_MIPS_R_TYPE (src[1].r_info);
  mirel.r_ssym = ELF64_MIPS_R_SSYM (src[1].r_info);
  mirel.r_type3 = ELF64_MIPS_R_TYPE (src[2].r_info);

  mips_elf64_swap_reloc_out (abfd, &mirel,
                          (Elf64_Mips_External_Rel *) dst);
}

Here is the call graph for this function:

static void mips_elf64_be_swap_reloca_in ( bfd abfd,
const bfd_byte src,
Elf_Internal_Rela dst 
) [static]

Definition at line 1749 of file elf64-mips.c.

{
  Elf64_Mips_Internal_Rela mirela;

  mips_elf64_swap_reloca_in (abfd,
                          (const Elf64_Mips_External_Rela *) src,
                          &mirela);

  dst[0].r_offset = mirela.r_offset;
  dst[0].r_info = ELF64_R_INFO (mirela.r_sym, mirela.r_type);
  dst[0].r_addend = mirela.r_addend;
  dst[1].r_offset = mirela.r_offset;
  dst[1].r_info = ELF64_R_INFO (mirela.r_ssym, mirela.r_type2);
  dst[1].r_addend = 0;
  dst[2].r_offset = mirela.r_offset;
  dst[2].r_info = ELF64_R_INFO (STN_UNDEF, mirela.r_type3);
  dst[2].r_addend = 0;
}

Here is the call graph for this function:

static void mips_elf64_be_swap_reloca_out ( bfd abfd,
const Elf_Internal_Rela src,
bfd_byte dst 
) [static]

Definition at line 1793 of file elf64-mips.c.

{
  Elf64_Mips_Internal_Rela mirela;

  mirela.r_offset = src[0].r_offset;
  BFD_ASSERT(src[0].r_offset == src[1].r_offset);
  BFD_ASSERT(src[0].r_offset == src[2].r_offset);

  mirela.r_type = ELF64_MIPS_R_TYPE (src[0].r_info);
  mirela.r_sym = ELF64_R_SYM (src[0].r_info);
  mirela.r_addend = src[0].r_addend;
  BFD_ASSERT(src[1].r_addend == 0);
  BFD_ASSERT(src[2].r_addend == 0);

  mirela.r_type2 = ELF64_MIPS_R_TYPE (src[1].r_info);
  mirela.r_ssym = ELF64_MIPS_R_SSYM (src[1].r_info);
  mirela.r_type3 = ELF64_MIPS_R_TYPE (src[2].r_info);

  mips_elf64_swap_reloca_out (abfd, &mirela,
                           (Elf64_Mips_External_Rela *) dst);
}

Here is the call graph for this function:

static long mips_elf64_canonicalize_dynamic_reloc ( bfd abfd,
arelent **  storage,
asymbol **  syms 
) [static]

Definition at line 2352 of file elf64-mips.c.

{
  bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
  asection *s;
  long ret;

  if (elf_dynsymtab (abfd) == 0)
    {
      bfd_set_error (bfd_error_invalid_operation);
      return -1;
    }

  slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
  ret = 0;
  for (s = abfd->sections; s != NULL; s = s->next)
    {
      if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
         && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
             || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
       {
         arelent *p;
         long count, i;

         if (! (*slurp_relocs) (abfd, s, syms, TRUE))
           return -1;
         count = s->size / elf_section_data (s)->this_hdr.sh_entsize * 3;
         p = s->relocation;
         for (i = 0; i < count; i++)
           *storage++ = p++;
         ret += count;
       }
    }

  *storage = NULL;

  return ret;
}

Here is the call graph for this function:

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

Definition at line 2332 of file elf64-mips.c.

{
  arelent *tblptr;
  unsigned int i;
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);

  if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
    return -1;

  tblptr = section->relocation;
  for (i = 0; i < section->reloc_count * 3; i++)
    *relptr++ = tblptr++;

  *relptr = NULL;

  return section->reloc_count * 3;
}
static bfd_reloc_status_type mips_elf64_final_gp ( bfd output_bfd,
asymbol symbol,
bfd_boolean  relocatable,
char **  error_message,
bfd_vma pgp 
) [static]

Definition at line 1872 of file elf64-mips.c.

{
  if (bfd_is_und_section (symbol->section)
      && ! relocatable)
    {
      *pgp = 0;
      return bfd_reloc_undefined;
    }

  *pgp = _bfd_get_gp_value (output_bfd);
  if (*pgp == 0
      && (! relocatable
         || (symbol->flags & BSF_SECTION_SYM) != 0))
    {
      if (relocatable)
       {
         /* Make up a value.  */
         *pgp = symbol->section->output_section->vma /*+ 0x4000*/;
         _bfd_set_gp_value (output_bfd, *pgp);
       }
      else if (!mips_elf64_assign_gp (output_bfd, pgp))
       {
         *error_message =
           (char *) _("GP relative relocation when _gp not defined");
         return bfd_reloc_dangerous;
       }
    }

  return bfd_reloc_ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static long mips_elf64_get_dynamic_reloc_upper_bound ( bfd abfd) [static]

Definition at line 2321 of file elf64-mips.c.

Here is the call graph for this function:

static long mips_elf64_get_reloc_upper_bound ( bfd ,
asection  
) [static]
static long mips_elf64_get_reloc_upper_bound ( bfd *abfd  ATTRIBUTE_UNUSED,
asection sec 
) [static]

Definition at line 2315 of file elf64-mips.c.

{
  return (sec->reloc_count * 3 + 1) * sizeof (arelent *);
}
static bfd_reloc_status_type mips_elf64_gprel16_reloc ( bfd abfd,
arelent reloc_entry,
asymbol symbol,
void *  data,
asection input_section,
bfd output_bfd,
char **  error_message 
) [static]

Definition at line 1908 of file elf64-mips.c.

{
  bfd_boolean relocatable;
  bfd_reloc_status_type ret;
  bfd_vma gp;

  /* If we're relocating, and this is an external symbol, we don't want
     to change anything.  */
  if (output_bfd != NULL
      && (symbol->flags & BSF_SECTION_SYM) == 0
      && (symbol->flags & BSF_LOCAL) != 0)
    {
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }

  if (output_bfd != NULL)
    relocatable = TRUE;
  else
    {
      relocatable = FALSE;
      output_bfd = symbol->section->output_section->owner;
    }

  ret = mips_elf64_final_gp (output_bfd, symbol, relocatable, error_message,
                          &gp);
  if (ret != bfd_reloc_ok)
    return ret;

  return _bfd_mips_elf_gprel16_with_gp (abfd, symbol, reloc_entry,
                                   input_section, relocatable,
                                   data, gp);
}

Here is the call graph for this function:

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

Definition at line 1988 of file elf64-mips.c.

{
  bfd_boolean relocatable;
  bfd_reloc_status_type ret;
  bfd_vma gp;
  bfd_vma relocation;
  bfd_vma val;

  /* R_MIPS_GPREL32 relocations are defined for local symbols only.  */
  if (output_bfd != NULL
      && (symbol->flags & BSF_SECTION_SYM) == 0
      && (symbol->flags & BSF_LOCAL) != 0)
    {
      *error_message = (char *)
       _("32bits gp relative relocation occurs for an external symbol");
      return bfd_reloc_outofrange;
    }

  if (output_bfd != NULL)
    relocatable = TRUE;
  else
    {
      relocatable = FALSE;
      output_bfd = symbol->section->output_section->owner;
    }

  ret = mips_elf64_final_gp (output_bfd, symbol, relocatable,
                          error_message, &gp);
  if (ret != bfd_reloc_ok)
    return ret;

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

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

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

  /* Set val to the offset into the section or symbol.  */
  val = reloc_entry->addend;

  if (reloc_entry->howto->partial_inplace)
    val += bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);

  /* Adjust val for the final section location and GP value.  If we
     are producing relocatable output, we don't want to do this for
     an external symbol.  */
  if (! relocatable
      || (symbol->flags & BSF_SECTION_SYM) != 0)
    val += relocation - gp;

  if (reloc_entry->howto->partial_inplace)
    bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
  else
    reloc_entry->addend = val;

  if (relocatable)
    reloc_entry->address += input_section->output_offset;

  return bfd_reloc_ok;
}

Here is the call graph for this function:

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

Definition at line 2296 of file elf64-mips.c.

{
  BFD_ASSERT (0);
}
static void mips_elf64_info_to_howto_rela ( bfd ,
arelent ,
Elf_Internal_Rela  
) [static]
static void mips_elf64_info_to_howto_rela ( bfd *abfd  ATTRIBUTE_UNUSED,
arelent *cache_ptr  ATTRIBUTE_UNUSED,
Elf_Internal_Rela *dst  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2304 of file elf64-mips.c.

{
  BFD_ASSERT (0);
}
static bfd_reloc_status_type mips_elf64_literal_reloc ( bfd abfd,
arelent reloc_entry,
asymbol symbol,
void *  data,
asection input_section,
bfd output_bfd,
char **  error_message 
) [static]

Definition at line 1947 of file elf64-mips.c.

{
  bfd_boolean relocatable;
  bfd_reloc_status_type ret;
  bfd_vma gp;

  /* R_MIPS_LITERAL relocations are defined for local symbols only.  */
  if (output_bfd != NULL
      && (symbol->flags & BSF_SECTION_SYM) == 0
      && (symbol->flags & BSF_LOCAL) != 0)
    {
      *error_message = (char *)
       _("literal relocation occurs for an external symbol");
      return bfd_reloc_outofrange;
    }

  /* FIXME: The entries in the .lit8 and .lit4 sections should be merged.  */
  if (output_bfd != NULL)
    relocatable = TRUE;
  else
    {
      relocatable = FALSE;
      output_bfd = symbol->section->output_section->owner;
    }

  ret = mips_elf64_final_gp (output_bfd, symbol, relocatable, error_message,
                          &gp);
  if (ret != bfd_reloc_ok)
    return ret;

  return _bfd_mips_elf_gprel16_with_gp (abfd, symbol, reloc_entry,
                                   input_section, relocatable,
                                   data, gp);
}

Here is the call graph for this function:

static bfd_boolean mips_elf64_object_p ( bfd abfd) [static]

Definition at line 2905 of file elf64-mips.c.

{
  unsigned long mach;

  /* Irix 6 is broken.  Object file symbol tables are not always
     sorted correctly such that local symbols precede global symbols,
     and the sh_info field in the symbol table is not always right.  */
  if (elf64_mips_irix_compat (abfd) != ict_none)
    elf_bad_symtab (abfd) = TRUE;

  mach = _bfd_elf_mips_mach (elf_elfheader (abfd)->e_flags);
  bfd_default_set_arch_mach (abfd, bfd_arch_mips, mach);
  return TRUE;
}

Here is the call graph for this function:

static reloc_howto_type * mips_elf64_rtype_to_howto ( unsigned int  r_type,
bfd_boolean  rela_p 
) [static]

Definition at line 2263 of file elf64-mips.c.

{
  switch (r_type)
    {
    case R_MIPS_GNU_VTINHERIT:
      return &elf_mips_gnu_vtinherit_howto;
    case R_MIPS_GNU_VTENTRY:
      return &elf_mips_gnu_vtentry_howto;
    case R_MIPS_GNU_REL16_S2:
      if (rela_p)
       return &elf_mips_gnu_rela16_s2;
      else
       return &elf_mips_gnu_rel16_s2;
    default:
      if (r_type >= R_MIPS16_min && r_type < R_MIPS16_max)
       {
         if (rela_p)
           return &mips16_elf64_howto_table_rela[r_type - R_MIPS16_min];
         else
           return &mips16_elf64_howto_table_rel[r_type - R_MIPS16_min];
       }
      BFD_ASSERT (r_type < (unsigned int) R_MIPS_max);
      if (rela_p)
       return &mips_elf64_howto_table_rela[r_type];
      else
       return &mips_elf64_howto_table_rel[r_type];
      break;
    }
}

Here is the caller graph for this function:

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

Definition at line 2060 of file elf64-mips.c.

{
  if (reloc_entry->howto->partial_inplace)
    {
      reloc_entry->addend = ((reloc_entry->addend & 0x00007c0)
                          | (reloc_entry->addend & 0x00000800) >> 9);
    }

  return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
                                  input_section, output_bfd,
                                  error_message);
}

Here is the call graph for this function:

static bfd_boolean mips_elf64_slurp_one_reloc_table ( bfd abfd,
asection asect,
Elf_Internal_Shdr rel_hdr,
bfd_size_type  reloc_count,
arelent relents,
asymbol **  symbols,
bfd_boolean  dynamic 
) [static]

Definition at line 2398 of file elf64-mips.c.

{
  void *allocated;
  bfd_byte *native_relocs;
  arelent *relent;
  bfd_vma i;
  int entsize;
  bfd_boolean rela_p;

  allocated = bfd_malloc (rel_hdr->sh_size);
  if (allocated == NULL)
    return FALSE;

  if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
      || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
         != rel_hdr->sh_size))
    goto error_return;

  native_relocs = allocated;

  entsize = rel_hdr->sh_entsize;
  BFD_ASSERT (entsize == sizeof (Elf64_Mips_External_Rel)
             || entsize == sizeof (Elf64_Mips_External_Rela));

  if (entsize == sizeof (Elf64_Mips_External_Rel))
    rela_p = FALSE;
  else
    rela_p = TRUE;

  for (i = 0, relent = relents;
       i < reloc_count;
       i++, native_relocs += entsize)
    {
      Elf64_Mips_Internal_Rela rela;
      bfd_boolean used_sym, used_ssym;
      int ir;

      if (entsize == sizeof (Elf64_Mips_External_Rela))
       mips_elf64_swap_reloca_in (abfd,
                               (Elf64_Mips_External_Rela *) native_relocs,
                               &rela);
      else
       mips_elf64_swap_reloc_in (abfd,
                              (Elf64_Mips_External_Rel *) native_relocs,
                              &rela);

      /* Each entry represents exactly three actual relocations.  */

      used_sym = FALSE;
      used_ssym = FALSE;
      for (ir = 0; ir < 3; ir++)
       {
         enum elf_mips_reloc_type type;

         switch (ir)
           {
           default:
             abort ();
           case 0:
             type = (enum elf_mips_reloc_type) rela.r_type;
             break;
           case 1:
             type = (enum elf_mips_reloc_type) rela.r_type2;
             break;
           case 2:
             type = (enum elf_mips_reloc_type) rela.r_type3;
             break;
           }

         /* Some types require symbols, whereas some do not.  */
         switch (type)
           {
           case R_MIPS_NONE:
           case R_MIPS_LITERAL:
           case R_MIPS_INSERT_A:
           case R_MIPS_INSERT_B:
           case R_MIPS_DELETE:
             relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
             break;

           default:
             if (! used_sym)
              {
                if (rela.r_sym == 0)
                  relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
                else
                  {
                    asymbol **ps, *s;

                    ps = symbols + rela.r_sym - 1;
                    s = *ps;
                    if ((s->flags & BSF_SECTION_SYM) == 0)
                     relent->sym_ptr_ptr = ps;
                    else
                     relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
                  }

                used_sym = TRUE;
              }
             else if (! used_ssym)
              {
                switch (rela.r_ssym)
                  {
                  case RSS_UNDEF:
                    relent->sym_ptr_ptr =
                     bfd_abs_section_ptr->symbol_ptr_ptr;
                    break;

                  case RSS_GP:
                  case RSS_GP0:
                  case RSS_LOC:
                    /* FIXME: I think these need to be handled using
                      special howto structures.  */
                    BFD_ASSERT (0);
                    break;

                  default:
                    BFD_ASSERT (0);
                    break;
                  }

                used_ssym = TRUE;
              }
             else
              relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;

             break;
           }

         /* The address of an ELF reloc is section relative for an
            object file, and absolute for an executable file or
            shared library.  The address of a BFD reloc is always
            section relative.  */
         if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
           relent->address = rela.r_offset;
         else
           relent->address = rela.r_offset - asect->vma;

         relent->addend = rela.r_addend;

         relent->howto = mips_elf64_rtype_to_howto (type, rela_p);

         ++relent;
       }
    }

  asect->reloc_count += (relent - relents) / 3;

  if (allocated != NULL)
    free (allocated);

  return TRUE;

 error_return:
  if (allocated != NULL)
    free (allocated);
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean mips_elf64_slurp_reloc_table ( bfd abfd,
asection asect,
asymbol **  symbols,
bfd_boolean  dynamic 
) [static]

Definition at line 2568 of file elf64-mips.c.

{
  struct bfd_elf_section_data * const d = elf_section_data (asect);
  Elf_Internal_Shdr *rel_hdr;
  Elf_Internal_Shdr *rel_hdr2;
  bfd_size_type reloc_count;
  bfd_size_type reloc_count2;
  arelent *relents;
  bfd_size_type amt;

  if (asect->relocation != NULL)
    return TRUE;

  if (! dynamic)
    {
      if ((asect->flags & SEC_RELOC) == 0
         || asect->reloc_count == 0)
       return TRUE;

      rel_hdr = &d->rel_hdr;
      reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
      rel_hdr2 = d->rel_hdr2;
      reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);

      BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
      BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
                || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));

    }
  else
    {
      /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
        case because relocations against this section may use the
        dynamic symbol table, and in that case bfd_section_from_shdr
        in elf.c does not update the RELOC_COUNT.  */
      if (asect->size == 0)
       return TRUE;

      rel_hdr = &d->this_hdr;
      reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
      rel_hdr2 = NULL;
      reloc_count2 = 0;
    }

  /* Allocate space for 3 arelent structures for each Rel structure.  */
  amt = (reloc_count + reloc_count2) * 3 * sizeof (arelent);
  relents = bfd_alloc (abfd, amt);
  if (relents == NULL)
    return FALSE;

  /* The slurp_one_reloc_table routine increments reloc_count.  */
  asect->reloc_count = 0;

  if (! mips_elf64_slurp_one_reloc_table (abfd, asect,
                                     rel_hdr, reloc_count,
                                     relents,
                                     symbols, dynamic))
    return FALSE;
  if (d->rel_hdr2 != NULL)
    {
      if (! mips_elf64_slurp_one_reloc_table (abfd, asect,
                                         rel_hdr2, reloc_count2,
                                         relents + reloc_count * 3,
                                         symbols, dynamic))
       return FALSE;
    }

  asect->relocation = relents;
  return TRUE;
}

Here is the call graph for this function:

static void mips_elf64_swap_reloc_in ( bfd abfd,
const Elf64_Mips_External_Rel src,
Elf64_Mips_Internal_Rela dst 
) [static]

Definition at line 1667 of file elf64-mips.c.

{
  dst->r_offset = H_GET_64 (abfd, src->r_offset);
  dst->r_sym = H_GET_32 (abfd, src->r_sym);
  dst->r_ssym = H_GET_8 (abfd, src->r_ssym);
  dst->r_type3 = H_GET_8 (abfd, src->r_type3);
  dst->r_type2 = H_GET_8 (abfd, src->r_type2);
  dst->r_type = H_GET_8 (abfd, src->r_type);
  dst->r_addend = 0;
}

Here is the caller graph for this function:

static void mips_elf64_swap_reloc_out ( bfd abfd,
const Elf64_Mips_Internal_Rela src,
Elf64_Mips_External_Rel dst 
) [static]

Definition at line 1697 of file elf64-mips.c.

{
  H_PUT_64 (abfd, src->r_offset, dst->r_offset);
  H_PUT_32 (abfd, src->r_sym, dst->r_sym);
  H_PUT_8 (abfd, src->r_ssym, dst->r_ssym);
  H_PUT_8 (abfd, src->r_type3, dst->r_type3);
  H_PUT_8 (abfd, src->r_type2, dst->r_type2);
  H_PUT_8 (abfd, src->r_type, dst->r_type);
}

Here is the caller graph for this function:

static void mips_elf64_swap_reloca_in ( bfd abfd,
const Elf64_Mips_External_Rela src,
Elf64_Mips_Internal_Rela dst 
) [static]

Definition at line 1682 of file elf64-mips.c.

{
  dst->r_offset = H_GET_64 (abfd, src->r_offset);
  dst->r_sym = H_GET_32 (abfd, src->r_sym);
  dst->r_ssym = H_GET_8 (abfd, src->r_ssym);
  dst->r_type3 = H_GET_8 (abfd, src->r_type3);
  dst->r_type2 = H_GET_8 (abfd, src->r_type2);
  dst->r_type = H_GET_8 (abfd, src->r_type);
  dst->r_addend = H_GET_S64 (abfd, src->r_addend);
}

Here is the caller graph for this function:

static void mips_elf64_swap_reloca_out ( bfd abfd,
const Elf64_Mips_Internal_Rela src,
Elf64_Mips_External_Rela dst 
) [static]

Definition at line 1711 of file elf64-mips.c.

{
  H_PUT_64 (abfd, src->r_offset, dst->r_offset);
  H_PUT_32 (abfd, src->r_sym, dst->r_sym);
  H_PUT_8 (abfd, src->r_ssym, dst->r_ssym);
  H_PUT_8 (abfd, src->r_type3, dst->r_type3);
  H_PUT_8 (abfd, src->r_type2, dst->r_type2);
  H_PUT_8 (abfd, src->r_type, dst->r_type);
  H_PUT_S64 (abfd, src->r_addend, dst->r_addend);
}

Here is the caller graph for this function:

static void mips_elf64_write_rel ( bfd abfd,
asection sec,
Elf_Internal_Shdr rel_hdr,
int count,
void *  data 
) [static]

Definition at line 2706 of file elf64-mips.c.

{
  bfd_boolean *failedp = data;
  Elf64_Mips_External_Rel *ext_rel;
  unsigned int idx;
  asymbol *last_sym = 0;
  int last_sym_idx = 0;

  rel_hdr->sh_size = rel_hdr->sh_entsize * *count;
  rel_hdr->contents = bfd_alloc (abfd, rel_hdr->sh_size);
  if (rel_hdr->contents == NULL)
    {
      *failedp = TRUE;
      return;
    }

  ext_rel = (Elf64_Mips_External_Rel *) rel_hdr->contents;
  for (idx = 0; idx < sec->reloc_count; idx++, ext_rel++)
    {
      arelent *ptr;
      Elf64_Mips_Internal_Rela int_rel;
      asymbol *sym;
      int n;
      unsigned int i;

      ptr = sec->orelocation[idx];

      /* The address of an ELF reloc is section relative for an object
        file, and absolute for an executable file or shared library.
        The address of a BFD reloc is always section relative.  */
      if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
       int_rel.r_offset = ptr->address;
      else
       int_rel.r_offset = ptr->address + sec->vma;

      sym = *ptr->sym_ptr_ptr;
      if (sym == last_sym)
       n = last_sym_idx;
      else if (bfd_is_abs_section (sym->section) && sym->value == 0)
       n = STN_UNDEF;
      else
       {
         last_sym = sym;
         n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
         if (n < 0)
           {
             *failedp = TRUE;
             return;
           }
         last_sym_idx = n;
       }

      int_rel.r_sym = n;
      int_rel.r_ssym = RSS_UNDEF;

      if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
         && ! _bfd_elf_validate_reloc (abfd, ptr))
       {
         *failedp = TRUE;
         return;
       }

      int_rel.r_type = ptr->howto->type;
      int_rel.r_type2 = (int) R_MIPS_NONE;
      int_rel.r_type3 = (int) R_MIPS_NONE;

      for (i = 0; i < 2; i++)
       {
         arelent *r;

         if (idx + 1 >= sec->reloc_count)
           break;
         r = sec->orelocation[idx + 1];
         if (r->address != ptr->address
             || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
             || (*r->sym_ptr_ptr)->value != 0)
           break;

         /* We can merge the reloc at IDX + 1 with the reloc at IDX.  */

         if (i == 0)
           int_rel.r_type2 = r->howto->type;
         else
           int_rel.r_type3 = r->howto->type;

         ++idx;
       }

      mips_elf64_swap_reloc_out (abfd, &int_rel, ext_rel);
    }

  BFD_ASSERT (ext_rel - (Elf64_Mips_External_Rel *) rel_hdr->contents
             == *count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mips_elf64_write_rela ( bfd abfd,
asection sec,
Elf_Internal_Shdr rela_hdr,
int count,
void *  data 
) [static]

Definition at line 2804 of file elf64-mips.c.

{
  bfd_boolean *failedp = data;
  Elf64_Mips_External_Rela *ext_rela;
  unsigned int idx;
  asymbol *last_sym = 0;
  int last_sym_idx = 0;

  rela_hdr->sh_size = rela_hdr->sh_entsize * *count;
  rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
  if (rela_hdr->contents == NULL)
    {
      *failedp = TRUE;
      return;
    }

  ext_rela = (Elf64_Mips_External_Rela *) rela_hdr->contents;
  for (idx = 0; idx < sec->reloc_count; idx++, ext_rela++)
    {
      arelent *ptr;
      Elf64_Mips_Internal_Rela int_rela;
      asymbol *sym;
      int n;
      unsigned int i;

      ptr = sec->orelocation[idx];

      /* The address of an ELF reloc is section relative for an object
        file, and absolute for an executable file or shared library.
        The address of a BFD reloc is always section relative.  */
      if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
       int_rela.r_offset = ptr->address;
      else
       int_rela.r_offset = ptr->address + sec->vma;

      sym = *ptr->sym_ptr_ptr;
      if (sym == last_sym)
       n = last_sym_idx;
      else if (bfd_is_abs_section (sym->section) && sym->value == 0)
       n = STN_UNDEF;
      else
       {
         last_sym = sym;
         n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
         if (n < 0)
           {
             *failedp = TRUE;
             return;
           }
         last_sym_idx = n;
       }

      int_rela.r_sym = n;
      int_rela.r_addend = ptr->addend;
      int_rela.r_ssym = RSS_UNDEF;

      if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
         && ! _bfd_elf_validate_reloc (abfd, ptr))
       {
         *failedp = TRUE;
         return;
       }

      int_rela.r_type = ptr->howto->type;
      int_rela.r_type2 = (int) R_MIPS_NONE;
      int_rela.r_type3 = (int) R_MIPS_NONE;

      for (i = 0; i < 2; i++)
       {
         arelent *r;

         if (idx + 1 >= sec->reloc_count)
           break;
         r = sec->orelocation[idx + 1];
         if (r->address != ptr->address
             || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
             || (*r->sym_ptr_ptr)->value != 0)
           break;

         /* We can merge the reloc at IDX + 1 with the reloc at IDX.  */

         if (i == 0)
           int_rela.r_type2 = r->howto->type;
         else
           int_rela.r_type3 = r->howto->type;

         ++idx;
       }

      mips_elf64_swap_reloca_out (abfd, &int_rela, ext_rela);
    }

  BFD_ASSERT (ext_rela - (Elf64_Mips_External_Rela *) rela_hdr->contents
             == *count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mips_elf64_write_relocs ( bfd abfd,
asection sec,
void *  data 
) [static]

Definition at line 2643 of file elf64-mips.c.

{
  bfd_boolean *failedp = data;
  int count;
  Elf_Internal_Shdr *rel_hdr;
  unsigned int idx;

  /* If we have already failed, don't do anything.  */
  if (*failedp)
    return;

  if ((sec->flags & SEC_RELOC) == 0)
    return;

  /* The linker backend writes the relocs out itself, and sets the
     reloc_count field to zero to inhibit writing them here.  Also,
     sometimes the SEC_RELOC flag gets set even when there aren't any
     relocs.  */
  if (sec->reloc_count == 0)
    return;

  /* We can combine up to three relocs that refer to the same address
     if the latter relocs have no associated symbol.  */
  count = 0;
  for (idx = 0; idx < sec->reloc_count; idx++)
    {
      bfd_vma addr;
      unsigned int i;

      ++count;

      addr = sec->orelocation[idx]->address;
      for (i = 0; i < 2; i++)
       {
         arelent *r;

         if (idx + 1 >= sec->reloc_count)
           break;
         r = sec->orelocation[idx + 1];
         if (r->address != addr
             || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
             || (*r->sym_ptr_ptr)->value != 0)
           break;

         /* We can merge the reloc at IDX + 1 with the reloc at IDX.  */

         ++idx;
       }
    }

  rel_hdr = &elf_section_data (sec)->rel_hdr;

  /* Do the actual relocation.  */

  if (rel_hdr->sh_entsize == sizeof(Elf64_Mips_External_Rel))
    mips_elf64_write_rel (abfd, sec, rel_hdr, &count, data);
  else if (rel_hdr->sh_entsize == sizeof(Elf64_Mips_External_Rela))
    mips_elf64_write_rela (abfd, sec, rel_hdr, &count, data);
  else
    BFD_ASSERT (0);
}

Here is the call graph for this function:


Variable Documentation

Definition at line 2995 of file elf64-mips.c.

reloc_howto_type elf_mips_gnu_rel16_s2 [static]
Initial value:
  HOWTO (R_MIPS_GNU_REL16_S2,      
        2,                  
        2,                  
        16,                 
        TRUE,               
        0,                  
        complain_overflow_signed, 
        _bfd_mips_elf_generic_reloc,      
        "R_MIPS_GNU_REL16_S2",     
        TRUE,               
        0x0000ffff,         
        0x0000ffff,         
        TRUE)

Definition at line 1633 of file elf64-mips.c.

reloc_howto_type elf_mips_gnu_rela16_s2 [static]
Initial value:
  HOWTO (R_MIPS_GNU_REL16_S2,      
        2,                  
        2,                  
        16,                 
        TRUE,               
        0,                  
        complain_overflow_signed, 
        _bfd_mips_elf_generic_reloc,      
        "R_MIPS_GNU_REL16_S2",     
        FALSE,                     
        0,                  
        0x0000ffff,         
        TRUE)

Definition at line 1649 of file elf64-mips.c.

reloc_howto_type elf_mips_gnu_vtentry_howto [static]
Initial value:
  HOWTO (R_MIPS_GNU_VTENTRY,       
        0,                  
        2,                  
        0,                  
        FALSE,                     
        0,                  
        complain_overflow_dont, 
        _bfd_elf_rel_vtable_reloc_fn, 
        "R_MIPS_GNU_VTENTRY",      
        FALSE,                     
        0,                  
        0,                  
        FALSE)

Definition at line 1617 of file elf64-mips.c.

reloc_howto_type elf_mips_gnu_vtinherit_howto [static]
Initial value:
  HOWTO (R_MIPS_GNU_VTINHERIT,     
        0,                  
        2,                  
        0,                  
        FALSE,                     
        0,                  
        complain_overflow_dont, 
        NULL,               
        "R_MIPS_GNU_VTINHERIT", 
        FALSE,                     
        0,                  
        0,                  
        FALSE)

Definition at line 1601 of file elf64-mips.c.

static struct elf_reloc_map [static]

Definition at line 2129 of file elf64-mips.c.

reloc_howto_type mips16_elf64_howto_table_rel[] [static]

Definition at line 1456 of file elf64-mips.c.

reloc_howto_type mips16_elf64_howto_table_rela[] [static]

Definition at line 1528 of file elf64-mips.c.

reloc_howto_type mips_elf64_howto_table_rel[] [static]

Definition at line 142 of file elf64-mips.c.

reloc_howto_type mips_elf64_howto_table_rela[] [static]

Definition at line 811 of file elf64-mips.c.