Subversion Repositories openrisc_me

/* MIPS-specific support for ELF

   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,

   2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.

   Most of the information added by Ian Lance Taylor, Cygnus Support,

   <ian@cygnus.com>.

   N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.

   <mark@codesourcery.com>

   Traditional MIPS targets support added by Koundinya.K, Dansk Data

   Elektronik & Operations Research Group. <kk@ddeorg.soft.net>

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/* This file handles functionality common to the different MIPS ABI's.  */

#include "sysdep.h"

#include "bfd.h"

#include "libbfd.h"

#include "libiberty.h"

#include "elf-bfd.h"

#include "elfxx-mips.h"

#include "elf/mips.h"

#include "elf-vxworks.h"

/* Get the ECOFF swapping routines.  */

#include "coff/sym.h"

#include "coff/symconst.h"

#include "coff/ecoff.h"

#include "coff/mips.h"

#include "hashtab.h"

/* This structure is used to hold information about one GOT entry.

   There are three types of entry:

      (1) absolute addresses

            (abfd == NULL)

      (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd

            (abfd != NULL, symndx >= 0)

      (3) global and forced-local symbols

            (abfd != NULL, symndx == -1)

   Type (3) entries are treated differently for different types of GOT.

   In the "master" GOT -- i.e.  the one that describes every GOT

   reference needed in the link -- the mips_got_entry is keyed on both

   the symbol and the input bfd that references it.  If it turns out

   that we need multiple GOTs, we can then use this information to

   create separate GOTs for each input bfd.

   However, we want each of these separate GOTs to have at most one

   entry for a given symbol, so their type (3) entries are keyed only

   on the symbol.  The input bfd given by the "abfd" field is somewhat

   arbitrary in this case.

   This means that when there are multiple GOTs, each GOT has a unique

   mips_got_entry for every symbol within it.  We can therefore use the

   mips_got_entry fields (tls_type and gotidx) to track the symbol's

   GOT index.

   However, if it turns out that we need only a single GOT, we continue

   to use the master GOT to describe it.  There may therefore be several

   mips_got_entries for the same symbol, each with a different input bfd.

   We want to make sure that each symbol gets a unique GOT entry, so when

   there's a single GOT, we use the symbol's hash entry, not the

   mips_got_entry fields, to track a symbol's GOT index.  */

struct mips_got_entry

{

  /* The input bfd in which the symbol is defined.  */

  bfd *abfd;

  /* The index of the symbol, as stored in the relocation r_info, if

     we have a local symbol; -1 otherwise.  */

  long symndx;

  union

  {

    /* If abfd == NULL, an address that must be stored in the got.  */

    bfd_vma address;

    /* If abfd != NULL && symndx != -1, the addend of the relocation

       that should be added to the symbol value.  */

    bfd_vma addend;

    /* If abfd != NULL && symndx == -1, the hash table entry

       corresponding to a global symbol in the got (or, local, if

       h->forced_local).  */

    struct mips_elf_link_hash_entry *h;

  } d;

  /* The TLS types included in this GOT entry (specifically, GD and

     IE).  The GD and IE flags can be added as we encounter new

     relocations.  LDM can also be set; it will always be alone, not

     combined with any GD or IE flags.  An LDM GOT entry will be

     a local symbol entry with r_symndx == 0.  */

  unsigned char tls_type;

  /* The offset from the beginning of the .got section to the entry

     corresponding to this symbol+addend.  If it's a global symbol

     whose offset is yet to be decided, it's going to be -1.  */

  long gotidx;

};

/* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].

   The structures form a non-overlapping list that is sorted by increasing

   MIN_ADDEND.  */

struct mips_got_page_range

{

  struct mips_got_page_range *next;

  bfd_signed_vma min_addend;

  bfd_signed_vma max_addend;

};

/* This structure describes the range of addends that are applied to page

   relocations against a given symbol.  */

struct mips_got_page_entry

{

  /* The input bfd in which the symbol is defined.  */

  bfd *abfd;

  /* The index of the symbol, as stored in the relocation r_info.  */

  long symndx;

  /* The ranges for this page entry.  */

  struct mips_got_page_range *ranges;

  /* The maximum number of page entries needed for RANGES.  */

  bfd_vma num_pages;

};

/* This structure is used to hold .got information when linking.  */

struct mips_got_info

{

  /* The global symbol in the GOT with the lowest index in the dynamic

     symbol table.  */

  struct elf_link_hash_entry *global_gotsym;

  /* The number of global .got entries.  */

  unsigned int global_gotno;

  /* The number of .got slots used for TLS.  */

  unsigned int tls_gotno;

  /* The first unused TLS .got entry.  Used only during

     mips_elf_initialize_tls_index.  */

  unsigned int tls_assigned_gotno;

  /* The number of local .got entries, eventually including page entries.  */

  unsigned int local_gotno;

  /* The maximum number of page entries needed.  */

  unsigned int page_gotno;

  /* The number of local .got entries we have used.  */

  unsigned int assigned_gotno;

  /* A hash table holding members of the got.  */

  struct htab *got_entries;

  /* A hash table of mips_got_page_entry structures.  */

  struct htab *got_page_entries;

  /* A hash table mapping input bfds to other mips_got_info.  NULL

     unless multi-got was necessary.  */

  struct htab *bfd2got;

  /* In multi-got links, a pointer to the next got (err, rather, most

     of the time, it points to the previous got).  */

  struct mips_got_info *next;

  /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE

     for none, or MINUS_TWO for not yet assigned.  This is needed

     because a single-GOT link may have multiple hash table entries

     for the LDM.  It does not get initialized in multi-GOT mode.  */

  bfd_vma tls_ldm_offset;

};

/* Map an input bfd to a got in a multi-got link.  */

struct mips_elf_bfd2got_hash {

  bfd *bfd;

  struct mips_got_info *g;

};

/* Structure passed when traversing the bfd2got hash table, used to

   create and merge bfd's gots.  */

struct mips_elf_got_per_bfd_arg

{

  /* A hashtable that maps bfds to gots.  */

  htab_t bfd2got;

  /* The output bfd.  */

  bfd *obfd;

  /* The link information.  */

  struct bfd_link_info *info;

  /* A pointer to the primary got, i.e., the one that's going to get

     the implicit relocations from DT_MIPS_LOCAL_GOTNO and

     DT_MIPS_GOTSYM.  */

  struct mips_got_info *primary;

  /* A non-primary got we're trying to merge with other input bfd's

     gots.  */

  struct mips_got_info *current;

  /* The maximum number of got entries that can be addressed with a

     16-bit offset.  */

  unsigned int max_count;

  /* The maximum number of page entries needed by each got.  */

  unsigned int max_pages;

  /* The total number of global entries which will live in the

     primary got and be automatically relocated.  This includes

     those not referenced by the primary GOT but included in

     the "master" GOT.  */

  unsigned int global_count;

};

/* Another structure used to pass arguments for got entries traversal.  */

struct mips_elf_set_global_got_offset_arg

{

  struct mips_got_info *g;

  int value;

  unsigned int needed_relocs;

  struct bfd_link_info *info;

};

/* A structure used to count TLS relocations or GOT entries, for GOT

   entry or ELF symbol table traversal.  */

struct mips_elf_count_tls_arg

{

  struct bfd_link_info *info;

  unsigned int needed;

};

struct _mips_elf_section_data

{

  struct bfd_elf_section_data elf;

  union

  {

    struct mips_got_info *got_info;

    bfd_byte *tdata;

  } u;

};

#define mips_elf_section_data(sec) \

  ((struct _mips_elf_section_data *) elf_section_data (sec))

/* This structure is passed to mips_elf_sort_hash_table_f when sorting

   the dynamic symbols.  */

struct mips_elf_hash_sort_data

{

  /* The symbol in the global GOT with the lowest dynamic symbol table

     index.  */

  struct elf_link_hash_entry *low;

  /* The least dynamic symbol table index corresponding to a non-TLS

     symbol with a GOT entry.  */

  long min_got_dynindx;

  /* The greatest dynamic symbol table index corresponding to a symbol

     with a GOT entry that is not referenced (e.g., a dynamic symbol

     with dynamic relocations pointing to it from non-primary GOTs).  */

  long max_unref_got_dynindx;

  /* The greatest dynamic symbol table index not corresponding to a

     symbol without a GOT entry.  */

  long max_non_got_dynindx;

};

/* The MIPS ELF linker needs additional information for each symbol in

   the global hash table.  */

struct mips_elf_link_hash_entry

{

  struct elf_link_hash_entry root;

  /* External symbol information.  */

  EXTR esym;

  /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against

     this symbol.  */

  unsigned int possibly_dynamic_relocs;

  /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against

     a readonly section.  */

  bfd_boolean readonly_reloc;

  /* We must not create a stub for a symbol that has relocations

     related to taking the function's address, i.e. any but

     R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",

     p. 4-20.  */

  bfd_boolean no_fn_stub;

  /* If there is a stub that 32 bit functions should use to call this

     16 bit function, this points to the section containing the stub.  */

  asection *fn_stub;

  /* Whether we need the fn_stub; this is set if this symbol appears

     in any relocs other than a 16 bit call.  */

  bfd_boolean need_fn_stub;

  /* If there is a stub that 16 bit functions should use to call this

     32 bit function, this points to the section containing the stub.  */

  asection *call_stub;

  /* This is like the call_stub field, but it is used if the function

     being called returns a floating point value.  */

  asection *call_fp_stub;

  /* Are we forced local?  This will only be set if we have converted

     the initial global GOT entry to a local GOT entry.  */

  bfd_boolean forced_local;

  /* Are we referenced by some kind of relocation?  */

  bfd_boolean is_relocation_target;

  /* Are we referenced by branch relocations?  */

  bfd_boolean is_branch_target;

#define GOT_NORMAL      0

#define GOT_TLS_GD      1

#define GOT_TLS_LDM     2

#define GOT_TLS_IE      4

#define GOT_TLS_OFFSET_DONE    0x40

#define GOT_TLS_DONE    0x80

  unsigned char tls_type;

  /* This is only used in single-GOT mode; in multi-GOT mode there

     is one mips_got_entry per GOT entry, so the offset is stored

     there.  In single-GOT mode there may be many mips_got_entry

     structures all referring to the same GOT slot.  It might be

     possible to use root.got.offset instead, but that field is

     overloaded already.  */

  bfd_vma tls_got_offset;

};

/* MIPS ELF linker hash table.  */

struct mips_elf_link_hash_table

{

  struct elf_link_hash_table root;

#if 0

  /* We no longer use this.  */

  /* String section indices for the dynamic section symbols.  */

  bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];

#endif

  /* The number of .rtproc entries.  */

  bfd_size_type procedure_count;

  /* The size of the .compact_rel section (if SGI_COMPAT).  */

  bfd_size_type compact_rel_size;

  /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic

     entry is set to the address of __rld_obj_head as in IRIX5.  */

  bfd_boolean use_rld_obj_head;

  /* This is the value of the __rld_map or __rld_obj_head symbol.  */

  bfd_vma rld_value;

  /* This is set if we see any mips16 stub sections.  */

  bfd_boolean mips16_stubs_seen;

  /* True if we've computed the size of the GOT.  */

  bfd_boolean computed_got_sizes;

  /* True if we're generating code for VxWorks.  */

  bfd_boolean is_vxworks;

  /* True if we already reported the small-data section overflow.  */

  bfd_boolean small_data_overflow_reported;

  /* Shortcuts to some dynamic sections, or NULL if they are not

     being used.  */

  asection *srelbss;

  asection *sdynbss;

  asection *srelplt;

  asection *srelplt2;

  asection *sgotplt;

  asection *splt;

  /* The size of the PLT header in bytes (VxWorks only).  */

  bfd_vma plt_header_size;

  /* The size of a PLT entry in bytes (VxWorks only).  */

  bfd_vma plt_entry_size;

  /* The size of a function stub entry in bytes.  */

  bfd_vma function_stub_size;

};

#define TLS_RELOC_P(r_type) \

  (r_type == R_MIPS_TLS_DTPMOD32                \

   || r_type == R_MIPS_TLS_DTPMOD64             \

   || r_type == R_MIPS_TLS_DTPREL32             \

   || r_type == R_MIPS_TLS_DTPREL64             \

   || r_type == R_MIPS_TLS_GD                   \

   || r_type == R_MIPS_TLS_LDM                  \

   || r_type == R_MIPS_TLS_DTPREL_HI16          \

   || r_type == R_MIPS_TLS_DTPREL_LO16          \

   || r_type == R_MIPS_TLS_GOTTPREL             \

   || r_type == R_MIPS_TLS_TPREL32              \

   || r_type == R_MIPS_TLS_TPREL64              \

   || r_type == R_MIPS_TLS_TPREL_HI16           \

   || r_type == R_MIPS_TLS_TPREL_LO16)

/* Structure used to pass information to mips_elf_output_extsym.  */

struct extsym_info

{

  bfd *abfd;

  struct bfd_link_info *info;

  struct ecoff_debug_info *debug;

  const struct ecoff_debug_swap *swap;

  bfd_boolean failed;

};

/* The names of the runtime procedure table symbols used on IRIX5.  */

static const char * const mips_elf_dynsym_rtproc_names[] =

{

  "_procedure_table",

  "_procedure_string_table",

  "_procedure_table_size",

  NULL

};

/* These structures are used to generate the .compact_rel section on

   IRIX5.  */

typedef struct

{

  unsigned long id1;            /* Always one?  */

  unsigned long num;            /* Number of compact relocation entries.  */

  unsigned long id2;            /* Always two?  */

  unsigned long offset;         /* The file offset of the first relocation.  */

  unsigned long reserved0;      /* Zero?  */

  unsigned long reserved1;      /* Zero?  */

} Elf32_compact_rel;

typedef struct

{

  bfd_byte id1[4];

  bfd_byte num[4];

  bfd_byte id2[4];

  bfd_byte offset[4];

  bfd_byte reserved0[4];

  bfd_byte reserved1[4];

} Elf32_External_compact_rel;

typedef struct

{

  unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */

  unsigned int rtype : 4;       /* Relocation types. See below.  */

  unsigned int dist2to : 8;

  unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */

  unsigned long konst;          /* KONST field. See below.  */

  unsigned long vaddr;          /* VADDR to be relocated.  */

} Elf32_crinfo;

typedef struct

{

  unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */

  unsigned int rtype : 4;       /* Relocation types. See below.  */

  unsigned int dist2to : 8;

  unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */

  unsigned long konst;          /* KONST field. See below.  */

} Elf32_crinfo2;

typedef struct

{

  bfd_byte info[4];

  bfd_byte konst[4];

  bfd_byte vaddr[4];

} Elf32_External_crinfo;

typedef struct

{

  bfd_byte info[4];

  bfd_byte konst[4];

} Elf32_External_crinfo2;

/* These are the constants used to swap the bitfields in a crinfo.  */

#define CRINFO_CTYPE (0x1)

#define CRINFO_CTYPE_SH (31)

#define CRINFO_RTYPE (0xf)

#define CRINFO_RTYPE_SH (27)

#define CRINFO_DIST2TO (0xff)

#define CRINFO_DIST2TO_SH (19)

#define CRINFO_RELVADDR (0x7ffff)

#define CRINFO_RELVADDR_SH (0)

/* A compact relocation info has long (3 words) or short (2 words)

   formats.  A short format doesn't have VADDR field and relvaddr

   fields contains ((VADDR - vaddr of the previous entry) >> 2).  */

#define CRF_MIPS_LONG                   1

#define CRF_MIPS_SHORT                  0

/* There are 4 types of compact relocation at least. The value KONST

   has different meaning for each type:

   (type)               (konst)

   CT_MIPS_REL32        Address in data

   CT_MIPS_WORD         Address in word (XXX)

   CT_MIPS_GPHI_LO      GP - vaddr

   CT_MIPS_JMPAD        Address to jump

   */

#define CRT_MIPS_REL32                  0xa

#define CRT_MIPS_WORD                   0xb

#define CRT_MIPS_GPHI_LO                0xc

#define CRT_MIPS_JMPAD                  0xd

#define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))

#define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))

#define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))

#define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)

/* The structure of the runtime procedure descriptor created by the

   loader for use by the static exception system.  */

typedef struct runtime_pdr {

        bfd_vma adr;            /* Memory address of start of procedure.  */

        long    regmask;        /* Save register mask.  */

        long    regoffset;      /* Save register offset.  */

        long    fregmask;       /* Save floating point register mask.  */

        long    fregoffset;     /* Save floating point register offset.  */

        long    frameoffset;    /* Frame size.  */

        short   framereg;       /* Frame pointer register.  */

        short   pcreg;          /* Offset or reg of return pc.  */

        long    irpss;          /* Index into the runtime string table.  */

        long    reserved;

        struct exception_info *exception_info;/* Pointer to exception array.  */

} RPDR, *pRPDR;

#define cbRPDR sizeof (RPDR)

#define rpdNil ((pRPDR) 0)

static struct mips_got_entry *mips_elf_create_local_got_entry

  (bfd *, struct bfd_link_info *, bfd *, struct mips_got_info *, asection *,

   bfd_vma, unsigned long, struct mips_elf_link_hash_entry *, int);

static bfd_boolean mips_elf_sort_hash_table_f

  (struct mips_elf_link_hash_entry *, void *);

static bfd_vma mips_elf_high

  (bfd_vma);

static bfd_boolean mips16_stub_section_p

  (bfd *, asection *);

static bfd_boolean mips_elf_create_dynamic_relocation

  (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,

   struct mips_elf_link_hash_entry *, asection *, bfd_vma,

   bfd_vma *, asection *);

static hashval_t mips_elf_got_entry_hash

  (const void *);

static bfd_vma mips_elf_adjust_gp

  (bfd *, struct mips_got_info *, bfd *);

static struct mips_got_info *mips_elf_got_for_ibfd

  (struct mips_got_info *, bfd *);

/* This will be used when we sort the dynamic relocation records.  */

static bfd *reldyn_sorting_bfd;

/* Nonzero if ABFD is using the N32 ABI.  */

#define ABI_N32_P(abfd) \

  ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)

/* Nonzero if ABFD is using the N64 ABI.  */

#define ABI_64_P(abfd) \

  (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)

/* Nonzero if ABFD is using NewABI conventions.  */

#define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))

/* The IRIX compatibility level we are striving for.  */

#define IRIX_COMPAT(abfd) \

  (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))

/* Whether we are trying to be compatible with IRIX at all.  */

#define SGI_COMPAT(abfd) \

  (IRIX_COMPAT (abfd) != ict_none)

/* The name of the options section.  */

#define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \

  (NEWABI_P (abfd) ? ".MIPS.options" : ".options")

/* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.

   Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME.  */

#define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \

  (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)

/* Whether the section is readonly.  */

#define MIPS_ELF_READONLY_SECTION(sec) \

  ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))         \

   == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))

/* The name of the stub section.  */

#define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"

/* The size of an external REL relocation.  */

#define MIPS_ELF_REL_SIZE(abfd) \

  (get_elf_backend_data (abfd)->s->sizeof_rel)

/* The size of an external RELA relocation.  */

#define MIPS_ELF_RELA_SIZE(abfd) \

  (get_elf_backend_data (abfd)->s->sizeof_rela)

/* The size of an external dynamic table entry.  */

#define MIPS_ELF_DYN_SIZE(abfd) \

  (get_elf_backend_data (abfd)->s->sizeof_dyn)

/* The size of a GOT entry.  */

#define MIPS_ELF_GOT_SIZE(abfd) \

  (get_elf_backend_data (abfd)->s->arch_size / 8)

/* The size of a symbol-table entry.  */

#define MIPS_ELF_SYM_SIZE(abfd) \

  (get_elf_backend_data (abfd)->s->sizeof_sym)

/* The default alignment for sections, as a power of two.  */

#define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \

  (get_elf_backend_data (abfd)->s->log_file_align)

/* Get word-sized data.  */

#define MIPS_ELF_GET_WORD(abfd, ptr) \

  (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))

/* Put out word-sized data.  */

#define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \

  (ABI_64_P (abfd)                              \

   ? bfd_put_64 (abfd, val, ptr)                \

   : bfd_put_32 (abfd, val, ptr))

/* Add a dynamic symbol table-entry.  */

#define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)      \

  _bfd_elf_add_dynamic_entry (info, tag, val)

#define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)                      \

  (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))

/* Determine whether the internal relocation of index REL_IDX is REL

   (zero) or RELA (non-zero).  The assumption is that, if there are

   two relocation sections for this section, one of them is REL and

   the other is RELA.  If the index of the relocation we're testing is

   in range for the first relocation section, check that the external

   relocation size is that for RELA.  It is also assumed that, if

   rel_idx is not in range for the first section, and this first

   section contains REL relocs, then the relocation is in the second

   section, that is RELA.  */

#define MIPS_RELOC_RELA_P(abfd, sec, rel_idx)                           \

  ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr)                 \

    * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel              \

    > (bfd_vma)(rel_idx))                                               \

   == (elf_section_data (sec)->rel_hdr.sh_entsize                       \

       == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela)               \

           : sizeof (Elf32_External_Rela))))

/* The name of the dynamic relocation section.  */

#define MIPS_ELF_REL_DYN_NAME(INFO) \

  (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")

/* In case we're on a 32-bit machine, construct a 64-bit "-1" value

   from smaller values.  Start with zero, widen, *then* decrement.  */

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

#define MINUS_TWO       (((bfd_vma)0) - 2)

/* The number of local .got entries we reserve.  */

#define MIPS_RESERVED_GOTNO(INFO) \

  (mips_elf_hash_table (INFO)->is_vxworks ? 3 : 2)

/* The value to write into got[1] for SVR4 targets, to identify it is

   a GNU object.  The dynamic linker can then use got[1] to store the

   module pointer.  */

#define MIPS_ELF_GNU_GOT1_MASK(abfd) \

  ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))

/* The offset of $gp from the beginning of the .got section.  */

#define ELF_MIPS_GP_OFFSET(INFO) \

  (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)

/* The maximum size of the GOT for it to be addressable using 16-bit

   offsets from $gp.  */

#define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)

/* Instructions which appear in a stub.  */

#define STUB_LW(abfd)                                                   \

  ((ABI_64_P (abfd)                                                     \

    ? 0xdf998010                                /* ld t9,0x8010(gp) */  \

    : 0x8f998010))                              /* lw t9,0x8010(gp) */

#define STUB_MOVE(abfd)                                                 \

   ((ABI_64_P (abfd)                                                    \

     ? 0x03e0782d                               /* daddu t7,ra */       \

     : 0x03e07821))                             /* addu t7,ra */

#define STUB_LUI(VAL) (0x3c180000 + (VAL))      /* lui t8,VAL */

#define STUB_JALR 0x0320f809                    /* jalr t9,ra */

#define STUB_ORI(VAL) (0x37180000 + (VAL))      /* ori t8,t8,VAL */

#define STUB_LI16U(VAL) (0x34180000 + (VAL))    /* ori t8,zero,VAL unsigned */

#define STUB_LI16S(abfd, VAL)                                           \

   ((ABI_64_P (abfd)                                                    \

    ? (0x64180000 + (VAL))      /* daddiu t8,zero,VAL sign extended */  \

    : (0x24180000 + (VAL))))    /* addiu t8,zero,VAL sign extended */

#define MIPS_FUNCTION_STUB_NORMAL_SIZE 16

#define MIPS_FUNCTION_STUB_BIG_SIZE 20

/* The name of the dynamic interpreter.  This is put in the .interp

   section.  */

#define ELF_DYNAMIC_INTERPRETER(abfd)           \

   (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \

    : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \

    : "/usr/lib/libc.so.1")

#ifdef BFD64

#define MNAME(bfd,pre,pos) \

  (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))

#define ELF_R_SYM(bfd, i)                                       \

  (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))

#define ELF_R_TYPE(bfd, i)                                      \

  (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))

#define ELF_R_INFO(bfd, s, t)                                   \

  (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))

#else

#define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)

#define ELF_R_SYM(bfd, i)                                       \

  (ELF32_R_SYM (i))

#define ELF_R_TYPE(bfd, i)                                      \

  (ELF32_R_TYPE (i))

#define ELF_R_INFO(bfd, s, t)                                   \

  (ELF32_R_INFO (s, t))

#endif

  /* The mips16 compiler uses a couple of special sections to handle

     floating point arguments.

     Section names that look like .mips16.fn.FNNAME contain stubs that

     copy floating point arguments from the fp regs to the gp regs and

     then jump to FNNAME.  If any 32 bit function calls FNNAME, the

     call should be redirected to the stub instead.  If no 32 bit

     function calls FNNAME, the stub should be discarded.  We need to

     consider any reference to the function, not just a call, because

     if the address of the function is taken we will need the stub,

     since the address might be passed to a 32 bit function.

     Section names that look like .mips16.call.FNNAME contain stubs

     that copy floating point arguments from the gp regs to the fp

     regs and then jump to FNNAME.  If FNNAME is a 32 bit function,

     then any 16 bit function that calls FNNAME should be redirected

     to the stub instead.  If FNNAME is not a 32 bit function, the

     stub should be discarded.

     .mips16.call.fp.FNNAME sections are similar, but contain stubs

     which call FNNAME and then copy the return value from the fp regs

     to the gp regs.  These stubs store the return value in $18 while

     calling FNNAME; any function which might call one of these stubs

     must arrange to save $18 around the call.  (This case is not

     needed for 32 bit functions that call 16 bit functions, because

     16 bit functions always return floating point values in both

     $f0/$f1 and $2/$3.)

     Note that in all cases FNNAME might be defined statically.

     Therefore, FNNAME is not used literally.  Instead, the relocation

     information will indicate which symbol the section is for.

     We record any stubs that we find in the symbol table.  */

#define FN_STUB ".mips16.fn."

#define CALL_STUB ".mips16.call."

#define CALL_FP_STUB ".mips16.call.fp."

#define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)

#define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)

#define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)

/* The format of the first PLT entry in a VxWorks executable.  */

static const bfd_vma mips_vxworks_exec_plt0_entry[] = {

  0x3c190000,   /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_)           */

  0x27390000,   /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_)     */

  0x8f390008,   /* lw t9, 8(t9)                                 */

  0x00000000,   /* nop                                          */

  0x03200008,   /* jr t9                                        */

  0x00000000    /* nop                                          */

};

/* The format of subsequent PLT entries.  */

static const bfd_vma mips_vxworks_exec_plt_entry[] = {

  0x10000000,   /* b .PLT_resolver                      */

  0x24180000,   /* li t8, <pltindex>                    */

  0x3c190000,   /* lui t9, %hi(<.got.plt slot>)         */

  0x27390000,   /* addiu t9, t9, %lo(<.got.plt slot>)   */

  0x8f390000,   /* lw t9, 0(t9)                         */