Subversion Repositories openrisc

/* MIPS-specific support for ELF

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

   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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 global .got entries that are in the GGA_RELOC_ONLY area.  */

  unsigned int reloc_only_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

  {

    bfd_byte *tdata;

  } u;

};

#define mips_elf_section_data(sec) \

  ((struct _mips_elf_section_data *) elf_section_data (sec))

#define is_mips_elf(bfd)                                \

  (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \

   && elf_tdata (bfd) != NULL                           \

   && elf_object_id (bfd) == MIPS_ELF_DATA)

/* The ABI says that every symbol used by dynamic relocations must have

   a global GOT entry.  Among other things, this provides the dynamic

   linker with a free, directly-indexed cache.  The GOT can therefore

   contain symbols that are not referenced by GOT relocations themselves

   (in other words, it may have symbols that are not referenced by things

   like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).

   GOT relocations are less likely to overflow if we put the associated

   GOT entries towards the beginning.  We therefore divide the global

   GOT entries into two areas: "normal" and "reloc-only".  Entries in

   the first area can be used for both dynamic relocations and GP-relative

   accesses, while those in the "reloc-only" area are for dynamic

   relocations only.

   These GGA_* ("Global GOT Area") values are organised so that lower

   values are more general than higher values.  Also, non-GGA_NONE

   values are ordered by the position of the area in the GOT.  */

#define GGA_NORMAL 0

#define GGA_RELOC_ONLY 1

#define GGA_NONE 2

/* Information about a non-PIC interface to a PIC function.  There are

   two ways of creating these interfaces.  The first is to add:

        lui     $25,%hi(func)

        addiu   $25,$25,%lo(func)

   immediately before a PIC function "func".  The second is to add:

        lui     $25,%hi(func)

        j       func

        addiu   $25,$25,%lo(func)

   to a separate trampoline section.

   Stubs of the first kind go in a new section immediately before the

   target function.  Stubs of the second kind go in a single section

   pointed to by the hash table's "strampoline" field.  */

struct mips_elf_la25_stub {

  /* The generated section that contains this stub.  */

  asection *stub_section;

  /* The offset of the stub from the start of STUB_SECTION.  */

  bfd_vma offset;

  /* One symbol for the original function.  Its location is available

     in H->root.root.u.def.  */

  struct mips_elf_link_hash_entry *h;

};

/* Macros for populating a mips_elf_la25_stub.  */

#define LA25_LUI(VAL) (0x3c190000 | (VAL))      /* lui t9,VAL */

#define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */

#define LA25_ADDIU(VAL) (0x27390000 | (VAL))    /* addiu t9,t9,VAL */

/* 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;

  /* The la25 stub we have created for ths symbol, if any.  */

  struct mips_elf_la25_stub *la25_stub;

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

     this symbol.  */

  unsigned int possibly_dynamic_relocs;

  /* 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;

  /* 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;

#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;

  /* The highest GGA_* value that satisfies all references to this symbol.  */

  unsigned int global_got_area : 2;

  /* True if one of the relocations described by possibly_dynamic_relocs

     is against a readonly section.  */

  unsigned int readonly_reloc : 1;

  /* True if there is a relocation against this symbol that must be

     resolved by the static linker (in other words, if the relocation

     cannot possibly be made dynamic).  */

  unsigned int has_static_relocs : 1;

  /* True if we must not create a .MIPS.stubs entry for this symbol.

     This is set, for example, if there are 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.  */

  unsigned int no_fn_stub : 1;

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

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

  unsigned int need_fn_stub : 1;

  /* True if this symbol is referenced by branch relocations from

     any non-PIC input file.  This is used to determine whether an

     la25 stub is required.  */

  unsigned int has_nonpic_branches : 1;

  /* Does this symbol need a traditional MIPS lazy-binding stub

     (as opposed to a PLT entry)?  */

  unsigned int needs_lazy_stub : 1;

};

/* 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 can generate copy relocs and PLTs.  */

  bfd_boolean use_plts_and_copy_relocs;

  /* 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;

  asection *sstubs;

  asection *sgot;

  /* The master GOT information.  */

  struct mips_got_info *got_info;

  /* The size of the PLT header in bytes.  */

  bfd_vma plt_header_size;

  /* The size of a PLT entry in bytes.  */

  bfd_vma plt_entry_size;

  /* The number of functions that need a lazy-binding stub.  */

  bfd_vma lazy_stub_count;

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

  bfd_vma function_stub_size;

  /* The number of reserved entries at the beginning of the GOT.  */

  unsigned int reserved_gotno;

  /* The section used for mips_elf_la25_stub trampolines.

     See the comment above that structure for details.  */

  asection *strampoline;

  /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)

     pairs.  */

  htab_t la25_stubs;

  /* A function FN (NAME, IS, OS) that creates a new input section

     called NAME and links it to output section OS.  If IS is nonnull,

     the new section should go immediately before it, otherwise it

     should go at the (current) beginning of OS.

     The function returns the new section on success, otherwise it

     returns null.  */

  asection *(*add_stub_section) (const char *, asection *, asection *);

};

/* Get the MIPS ELF linker hash table from a link_info structure.  */

#define mips_elf_hash_table(p) \

  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \

  == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)

/* A structure used to communicate with htab_traverse callbacks.  */

struct mips_htab_traverse_info

{

  /* The usual link-wide information.  */

  struct bfd_link_info *info;

  bfd *output_bfd;

  /* Starts off FALSE and is set to TRUE if the link should be aborted.  */

  bfd_boolean error;

};

#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 *, 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 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;

/* True if ABFD is for CPUs with load interlocking that include

   non-MIPS1 CPUs and R3900.  */

#define LOAD_INTERLOCKS_P(abfd) \

  (   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \

   || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))

/* True if ABFD is for CPUs that are faster if JAL is converted to BAL.

   This should be safe for all architectures.  We enable this predicate

   for RM9000 for now.  */

#define JAL_TO_BAL_P(abfd) \

  ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)

/* True if ABFD is for CPUs that are faster if JALR is converted to BAL.

   This should be safe for all architectures.  We enable this predicate for

   all CPUs.  */

#define JALR_TO_BAL_P(abfd) 1

/* True if ABFD is for CPUs that are faster if JR is converted to B.

   This should be safe for all architectures.  We enable this predicate for

   all CPUs.  */

#define JR_TO_B_P(abfd) 1

/* True if ABFD is a PIC object.  */

#define PIC_OBJECT_P(abfd) \

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

/* 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))

/* The opcode for word-sized loads (LW or LD).  */

#define MIPS_ELF_LOAD_WORD(abfd) \

  (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)

/* 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