bfd/elf32-mips.c

   1 /* MIPS-specific support for 32-bit ELF
   2    Copyright 1993, 94, 95, 96, 97, 98, 99, 2000
   3    Free Software Foundation, Inc.
   4
   5    Most of the information added by Ian Lance Taylor, Cygnus Support,
   6    <ian@cygnus.com>.
   7    N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
   8    <mark@codesourcery.com>
   9    Traditional MIPS targets support added by Koundinya.K, Dansk Data
  10    Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
  11
  12 This file is part of BFD, the Binary File Descriptor library.
  13
  14 This program is free software; you can redistribute it and/or modify
  15 it under the terms of the GNU General Public License as published by
  16 the Free Software Foundation; either version 2 of the License, or
  17 (at your option) any later version.
  18
  19 This program is distributed in the hope that it will be useful,
  20 but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 GNU General Public License for more details.
  23
  24 You should have received a copy of the GNU General Public License
  25 along with this program; if not, write to the Free Software
  26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  27
  28 /* This file handles MIPS ELF targets.  SGI Irix 5 uses a slightly
  29    different MIPS ELF from other targets.  This matters when linking.
  30    This file supports both, switching at runtime.  */
  31
  32 #include "bfd.h"
  33 #include "sysdep.h"
  34 #include "libbfd.h"
  35 #include "bfdlink.h"
  36 #include "genlink.h"
  37 #include "elf-bfd.h"
  38 #include "elf/mips.h"
  39
  40 /* Get the ECOFF swapping routines.  */
  41 #include "coff/sym.h"
  42 #include "coff/symconst.h"
  43 #include "coff/internal.h"
  44 #include "coff/ecoff.h"
  45 #include "coff/mips.h"
  46 #define ECOFF_SIGNED_32
  47 #include "ecoffswap.h"
  48
  49 /* This structure is used to hold .got information when linking.  It
  50    is stored in the tdata field of the bfd_elf_section_data structure.  */
  51
  52 struct mips_got_info {
  53   /* The global symbol in the GOT with the lowest index in the dynamic
  54      symbol table.  */
  55   struct elf_link_hash_entry *global_gotsym;
  56   /* The number of global .got entries.  */
  57   unsigned int global_gotno;
  58   /* The number of local .got entries.  */
  59   unsigned int local_gotno;
  60   /* The number of local .got entries we have used.  */
  61   unsigned int assigned_gotno;
  62 };
  63
  64 /* The MIPS ELF linker needs additional information for each symbol in
  65    the global hash table.  */
  66
  67 struct mips_elf_link_hash_entry {
  68   struct elf_link_hash_entry root;
  69
  70   /* External symbol information.  */
  71   EXTR esym;
  72
  73   /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
  74      this symbol.  */
  75   unsigned int possibly_dynamic_relocs;
  76
  77   /* The index of the first dynamic relocation (in the .rel.dyn
  78      section) against this symbol.  */
  79   unsigned int min_dyn_reloc_index;
  80
  81   /* If there is a stub that 32 bit functions should use to call this
  82      16 bit function, this points to the section containing the stub.  */
  83   asection *fn_stub;
  84
  85   /* Whether we need the fn_stub; this is set if this symbol appears
  86      in any relocs other than a 16 bit call.  */
  87   boolean need_fn_stub;
  88
  89   /* If there is a stub that 16 bit functions should use to call this
  90      32 bit function, this points to the section containing the stub.  */
  91   asection *call_stub;
  92
  93   /* This is like the call_stub field, but it is used if the function
  94      being called returns a floating point value.  */
  95   asection *call_fp_stub;
  96 };
  97
  98 static bfd_reloc_status_type mips32_64bit_reloc
  99   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 100 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
 101   PARAMS ((bfd *, bfd_reloc_code_real_type));
 102 static reloc_howto_type *mips_rtype_to_howto
 103   PARAMS ((unsigned int));
 104 static void mips_info_to_howto_rel
 105   PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
 106 static void mips_info_to_howto_rela
 107   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
 108 static void bfd_mips_elf32_swap_gptab_in
 109   PARAMS ((bfd *, const Elf32_External_gptab *, Elf32_gptab *));
 110 static void bfd_mips_elf32_swap_gptab_out
 111   PARAMS ((bfd *, const Elf32_gptab *, Elf32_External_gptab *));
 112 #if 0
 113 static void bfd_mips_elf_swap_msym_in
 114   PARAMS ((bfd *, const Elf32_External_Msym *, Elf32_Internal_Msym *));
 115 #endif
 116 static void bfd_mips_elf_swap_msym_out
 117   PARAMS ((bfd *, const Elf32_Internal_Msym *, Elf32_External_Msym *));
 118 static boolean mips_elf_sym_is_global PARAMS ((bfd *, asymbol *));
 119 static boolean mips_elf_create_procedure_table
 120   PARAMS ((PTR, bfd *, struct bfd_link_info *, asection *,
 121            struct ecoff_debug_info *));
 122 static INLINE int elf_mips_isa PARAMS ((flagword));
 123 static INLINE int elf_mips_mach PARAMS ((flagword));
 124 static INLINE char* elf_mips_abi_name PARAMS ((bfd *));
 125 static boolean mips_elf_is_local_label_name
 126   PARAMS ((bfd *, const char *));
 127 static struct bfd_hash_entry *mips_elf_link_hash_newfunc
 128   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 129 static int gptab_compare PARAMS ((const void *, const void *));
 130 static bfd_reloc_status_type mips16_jump_reloc
 131   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 132 static bfd_reloc_status_type mips16_gprel_reloc
 133   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 134 static boolean mips_elf_create_compact_rel_section
 135   PARAMS ((bfd *, struct bfd_link_info *));
 136 static boolean mips_elf_create_got_section
 137   PARAMS ((bfd *, struct bfd_link_info *));
 138 static bfd_reloc_status_type mips_elf_final_gp
 139   PARAMS ((bfd *, asymbol *, boolean, char **, bfd_vma *));
 140 static bfd_byte *elf32_mips_get_relocated_section_contents
 141   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
 142            bfd_byte *, boolean, asymbol **));
 143 static asection *mips_elf_create_msym_section
 144   PARAMS ((bfd *));
 145 static void mips_elf_irix6_finish_dynamic_symbol
 146   PARAMS ((bfd *, const char *, Elf_Internal_Sym *));
 147 static bfd_vma mips_elf_sign_extend PARAMS ((bfd_vma, int));
 148 static boolean mips_elf_overflow_p PARAMS ((bfd_vma, int));
 149 static bfd_vma mips_elf_high PARAMS ((bfd_vma));
 150 static bfd_vma mips_elf_higher PARAMS ((bfd_vma));
 151 static bfd_vma mips_elf_highest PARAMS ((bfd_vma));
 152 static bfd_vma mips_elf_global_got_index
 153   PARAMS ((bfd *, struct elf_link_hash_entry *));
 154 static bfd_vma mips_elf_local_got_index
 155   PARAMS ((bfd *, struct bfd_link_info *, bfd_vma));
 156 static bfd_vma mips_elf_got_offset_from_index
 157   PARAMS ((bfd *, bfd *, bfd_vma));
 158 static boolean mips_elf_record_global_got_symbol
 159   PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *,
 160            struct mips_got_info *));
 161 static bfd_vma mips_elf_got_page
 162   PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, bfd_vma *));
 163 static const Elf_Internal_Rela *mips_elf_next_relocation
 164   PARAMS ((unsigned int, const Elf_Internal_Rela *,
 165            const Elf_Internal_Rela *));
 166 static bfd_reloc_status_type mips_elf_calculate_relocation
 167   PARAMS ((bfd *, bfd *, asection *, struct bfd_link_info *,
 168            const Elf_Internal_Rela *, bfd_vma, reloc_howto_type *,
 169            Elf_Internal_Sym *, asection **, bfd_vma *, const char **,
 170            boolean *));
 171 static bfd_vma mips_elf_obtain_contents
 172   PARAMS ((reloc_howto_type *, const Elf_Internal_Rela *, bfd *, bfd_byte *));
 173 static boolean mips_elf_perform_relocation
 174   PARAMS ((struct bfd_link_info *, reloc_howto_type *,
 175            const Elf_Internal_Rela *, bfd_vma,
 176            bfd *, asection *, bfd_byte *, boolean));
 177 static boolean mips_elf_assign_gp PARAMS ((bfd *, bfd_vma *));
 178 static boolean mips_elf_sort_hash_table_f
 179   PARAMS ((struct mips_elf_link_hash_entry *, PTR));
 180 static boolean mips_elf_sort_hash_table
 181   PARAMS ((struct bfd_link_info *, unsigned long));
 182 static asection * mips_elf_got_section PARAMS ((bfd *));
 183 static struct mips_got_info *mips_elf_got_info
 184   PARAMS ((bfd *, asection **));
 185 static boolean mips_elf_local_relocation_p
 186   PARAMS ((bfd *, const Elf_Internal_Rela *, asection **, boolean));
 187 static bfd_vma mips_elf_create_local_got_entry
 188   PARAMS ((bfd *, struct mips_got_info *, asection *, bfd_vma));
 189 static bfd_vma mips_elf_got16_entry
 190   PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, boolean));
 191 static boolean mips_elf_create_dynamic_relocation
 192   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
 193            struct mips_elf_link_hash_entry *, asection *,
 194            bfd_vma, bfd_vma *, asection *, boolean local_p));
 195 static void mips_elf_allocate_dynamic_relocations
 196   PARAMS ((bfd *, unsigned int));
 197 static boolean mips_elf_stub_section_p
 198   PARAMS ((bfd *, asection *));
 199 static int sort_dynamic_relocs
 200   PARAMS ((const void *, const void *));
 201
 202 extern const bfd_target bfd_elf32_tradbigmips_vec;
 203
 204 /* The level of IRIX compatibility we're striving for.  */
 205
 206 typedef enum {
 207   ict_none,
 208   ict_irix5,
 209   ict_irix6
 210 } irix_compat_t;
 211
 212 /* This will be used when we sort the dynamic relocation records.  */
 213 static bfd *reldyn_sorting_bfd;
 214
 215 /* Nonzero if ABFD is using the N32 ABI.  */
 216
 217 #define ABI_N32_P(abfd) \
 218   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
 219
 220 /* Nonzero if ABFD is using the 64-bit ABI.  FIXME: This is never
 221    true, yet.  */
 222 #define ABI_64_P(abfd) \
 223   ((elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) != 0)
 224
 225 /* Depending on the target vector we generate some version of Irix
 226    executables or "normal" MIPS ELF ABI executables.  */
 227
 228 #define IRIX_COMPAT(abfd) \
 229   (abfd->xvec == &bfd_elf32_tradbigmips_vec ? ict_none : \
 230   ((ABI_N32_P (abfd) || ABI_64_P (abfd)) ? ict_irix6 : ict_irix5))
 231
 232 /* Whether we are trying to be compatible with IRIX at all.  */
 233
 234 #define SGI_COMPAT(abfd) \
 235   (IRIX_COMPAT (abfd) != ict_none)
 236
 237 /* The name of the msym section.  */
 238 #define MIPS_ELF_MSYM_SECTION_NAME(abfd) ".msym"
 239
 240 /* The name of the srdata section.  */
 241 #define MIPS_ELF_SRDATA_SECTION_NAME(abfd) ".srdata"
 242
 243 /* The name of the options section.  */
 244 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
 245   (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.options" : ".options")
 246
 247 /* The name of the stub section.  */
 248 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
 249   (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.stubs" : ".stub")
 250
 251 /* The name of the dynamic relocation section.  */
 252 #define MIPS_ELF_REL_DYN_SECTION_NAME(abfd) ".rel.dyn"
 253
 254 /* The size of an external REL relocation.  */
 255 #define MIPS_ELF_REL_SIZE(abfd) \
 256   (get_elf_backend_data (abfd)->s->sizeof_rel)
 257
 258 /* The size of an external dynamic table entry.  */
 259 #define MIPS_ELF_DYN_SIZE(abfd) \
 260   (get_elf_backend_data (abfd)->s->sizeof_dyn)
 261
 262 /* The size of a GOT entry.  */
 263 #define MIPS_ELF_GOT_SIZE(abfd) \
 264   (get_elf_backend_data (abfd)->s->arch_size / 8)
 265
 266 /* The size of a symbol-table entry.  */
 267 #define MIPS_ELF_SYM_SIZE(abfd) \
 268   (get_elf_backend_data (abfd)->s->sizeof_sym)
 269
 270 /* The default alignment for sections, as a power of two.  */
 271 #define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \
 272   (get_elf_backend_data (abfd)->s->file_align == 8 ? 3 : 2)
 273
 274 /* Get word-sized data.  */
 275 #define MIPS_ELF_GET_WORD(abfd, ptr) \
 276   (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
 277
 278 /* Put out word-sized data.  */
 279 #define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \
 280   (ABI_64_P (abfd)                              \
 281    ? bfd_put_64 (abfd, val, ptr)                \
 282    : bfd_put_32 (abfd, val, ptr))
 283
 284 /* Add a dynamic symbol table-entry.  */
 285 #ifdef BFD64
 286 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
 287   (ABI_64_P (elf_hash_table (info)->dynobj)        \
 288    ? bfd_elf64_add_dynamic_entry (info, tag, val)  \
 289    : bfd_elf32_add_dynamic_entry (info, tag, val))
 290 #else
 291 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
 292   (ABI_64_P (elf_hash_table (info)->dynobj)        \
 293    ? (abort (), false)                             \
 294    : bfd_elf32_add_dynamic_entry (info, tag, val))
 295 #endif
 296
 297 /* The number of local .got entries we reserve.  */
 298 #define MIPS_RESERVED_GOTNO (2)
 299
 300 /* Instructions which appear in a stub.  For some reason the stub is
 301    slightly different on an SGI system.  */
 302 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
 303 #define STUB_LW(abfd)                                           \
 304   (SGI_COMPAT (abfd)                                            \
 305    ? (ABI_64_P (abfd)                                           \
 306       ? 0xdf998010              /* ld t9,0x8010(gp) */          \
 307       : 0x8f998010)             /* lw t9,0x8010(gp) */          \
 308    : 0x8f998010)                /* lw t9,0x8000(gp) */
 309 #define STUB_MOVE(abfd)                                         \
 310   (SGI_COMPAT (abfd) ? 0x03e07825 : 0x03e07821)         /* move t7,ra */
 311 #define STUB_JALR 0x0320f809                            /* jal t9 */
 312 #define STUB_LI16(abfd)                                         \
 313   (SGI_COMPAT (abfd) ? 0x34180000 : 0x24180000)         /* ori t8,zero,0 */
 314 #define MIPS_FUNCTION_STUB_SIZE (16)
 315
 316 #if 0
 317 /* We no longer try to identify particular sections for the .dynsym
 318    section.  When we do, we wind up crashing if there are other random
 319    sections with relocations.  */
 320
 321 /* Names of sections which appear in the .dynsym section in an Irix 5
 322    executable.  */
 323
 324 static const char * const mips_elf_dynsym_sec_names[] = {
 325   ".text",
 326   ".init",
 327   ".fini",
 328   ".data",
 329   ".rodata",
 330   ".sdata",
 331   ".sbss",
 332   ".bss",
 333   NULL
 334 };
 335
 336 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
 337   (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
 338
 339 /* The number of entries in mips_elf_dynsym_sec_names which go in the
 340    text segment.  */
 341
 342 #define MIPS_TEXT_DYNSYM_SECNO (3)
 343
 344 #endif /* 0 */
 345
 346 /* The names of the runtime procedure table symbols used on Irix 5.  */
 347
 348 static const char * const mips_elf_dynsym_rtproc_names[] = {
 349   "_procedure_table",
 350   "_procedure_string_table",
 351   "_procedure_table_size",
 352   NULL
 353 };
 354
 355 /* These structures are used to generate the .compact_rel section on
 356    Irix 5.  */
 357
 358 typedef struct {
 359   unsigned long id1;            /* Always one?  */
 360   unsigned long num;            /* Number of compact relocation entries.  */
 361   unsigned long id2;            /* Always two?  */
 362   unsigned long offset;         /* The file offset of the first relocation.  */
 363   unsigned long reserved0;      /* Zero?  */
 364   unsigned long reserved1;      /* Zero?  */
 365 } Elf32_compact_rel;
 366
 367 typedef struct {
 368   bfd_byte id1[4];
 369   bfd_byte num[4];
 370   bfd_byte id2[4];
 371   bfd_byte offset[4];
 372   bfd_byte reserved0[4];
 373   bfd_byte reserved1[4];
 374 } Elf32_External_compact_rel;
 375
 376 typedef struct {
 377   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
 378   unsigned int rtype : 4;       /* Relocation types. See below.  */
 379   unsigned int dist2to : 8;
 380   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
 381   unsigned long konst;          /* KONST field. See below.  */
 382   unsigned long vaddr;          /* VADDR to be relocated.  */
 383 } Elf32_crinfo;
 384
 385 typedef struct {
 386   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
 387   unsigned int rtype : 4;       /* Relocation types. See below.  */
 388   unsigned int dist2to : 8;
 389   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
 390   unsigned long konst;          /* KONST field. See below.  */
 391 } Elf32_crinfo2;
 392
 393 typedef struct {
 394   bfd_byte info[4];
 395   bfd_byte konst[4];
 396   bfd_byte vaddr[4];
 397 } Elf32_External_crinfo;
 398
 399 typedef struct {
 400   bfd_byte info[4];
 401   bfd_byte konst[4];
 402 } Elf32_External_crinfo2;
 403
 404 /* These are the constants used to swap the bitfields in a crinfo.  */
 405
 406 #define CRINFO_CTYPE (0x1)
 407 #define CRINFO_CTYPE_SH (31)
 408 #define CRINFO_RTYPE (0xf)
 409 #define CRINFO_RTYPE_SH (27)
 410 #define CRINFO_DIST2TO (0xff)
 411 #define CRINFO_DIST2TO_SH (19)
 412 #define CRINFO_RELVADDR (0x7ffff)
 413 #define CRINFO_RELVADDR_SH (0)
 414
 415 /* A compact relocation info has long (3 words) or short (2 words)
 416    formats.  A short format doesn't have VADDR field and relvaddr
 417    fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
 418 #define CRF_MIPS_LONG                   1
 419 #define CRF_MIPS_SHORT                  0
 420
 421 /* There are 4 types of compact relocation at least. The value KONST
 422    has different meaning for each type:
 423
 424    (type)               (konst)
 425    CT_MIPS_REL32        Address in data
 426    CT_MIPS_WORD         Address in word (XXX)
 427    CT_MIPS_GPHI_LO      GP - vaddr
 428    CT_MIPS_JMPAD        Address to jump
 429    */
 430
 431 #define CRT_MIPS_REL32                  0xa
 432 #define CRT_MIPS_WORD                   0xb
 433 #define CRT_MIPS_GPHI_LO                0xc
 434 #define CRT_MIPS_JMPAD                  0xd
 435
 436 #define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))
 437 #define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))
 438 #define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))
 439 #define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)
 440
 441 static void bfd_elf32_swap_compact_rel_out
 442   PARAMS ((bfd *, const Elf32_compact_rel *, Elf32_External_compact_rel *));
 443 static void bfd_elf32_swap_crinfo_out
 444   PARAMS ((bfd *, const Elf32_crinfo *, Elf32_External_crinfo *));
 445
 446 #define USE_REL 1               /* MIPS uses REL relocations instead of RELA */
 447
 448 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 449    from smaller values.  Start with zero, widen, *then* decrement.  */
 450 #define MINUS_ONE       (((bfd_vma)0) - 1)
 451
 452 static reloc_howto_type elf_mips_howto_table[] = {
 453   /* No relocation.  */
 454   HOWTO (R_MIPS_NONE,           /* type */
 455          0,                     /* rightshift */
 456          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          0,                     /* bitsize */
 458          false,                 /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_dont, /* complain_on_overflow */
 461          bfd_elf_generic_reloc, /* special_function */
 462          "R_MIPS_NONE",         /* name */
 463          false,                 /* partial_inplace */
 464          0,                     /* src_mask */
 465          0,                     /* dst_mask */
 466          false),                /* pcrel_offset */
 467
 468   /* 16 bit relocation.  */
 469   HOWTO (R_MIPS_16,             /* type */
 470          0,                     /* rightshift */
 471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          16,                    /* bitsize */
 473          false,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_bitfield, /* complain_on_overflow */
 476          bfd_elf_generic_reloc, /* special_function */
 477          "R_MIPS_16",           /* name */
 478          true,                  /* partial_inplace */
 479          0xffff,                /* src_mask */
 480          0xffff,                /* dst_mask */
 481          false),                /* pcrel_offset */
 482
 483   /* 32 bit relocation.  */
 484   HOWTO (R_MIPS_32,             /* type */
 485          0,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          32,                    /* bitsize */
 488          false,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_bitfield, /* complain_on_overflow */
 491          bfd_elf_generic_reloc, /* special_function */
 492          "R_MIPS_32",           /* name */
 493          true,                  /* partial_inplace */
 494          0xffffffff,            /* src_mask */
 495          0xffffffff,            /* dst_mask */
 496          false),                /* pcrel_offset */
 497
 498   /* 32 bit symbol relative relocation.  */
 499   HOWTO (R_MIPS_REL32,          /* type */
 500          0,                     /* rightshift */
 501          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 502          32,                    /* bitsize */
 503          false,                 /* pc_relative */
 504          0,                     /* bitpos */
 505          complain_overflow_bitfield, /* complain_on_overflow */
 506          bfd_elf_generic_reloc, /* special_function */
 507          "R_MIPS_REL32",        /* name */
 508          true,                  /* partial_inplace */
 509          0xffffffff,            /* src_mask */
 510          0xffffffff,            /* dst_mask */
 511          false),                /* pcrel_offset */
 512
 513   /* 26 bit branch address.  */
 514   HOWTO (R_MIPS_26,             /* type */
 515          2,                     /* rightshift */
 516          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 517          26,                    /* bitsize */
 518          false,                 /* pc_relative */
 519          0,                     /* bitpos */
 520          complain_overflow_dont, /* complain_on_overflow */
 521                                 /* This needs complex overflow
 522                                    detection, because the upper four
 523                                    bits must match the PC.  */
 524          bfd_elf_generic_reloc, /* special_function */
 525          "R_MIPS_26",           /* name */
 526          true,                  /* partial_inplace */
 527          0x3ffffff,             /* src_mask */
 528          0x3ffffff,             /* dst_mask */
 529          false),                /* pcrel_offset */
 530
 531   /* High 16 bits of symbol value.  */
 532   HOWTO (R_MIPS_HI16,           /* type */
 533          0,                     /* rightshift */
 534          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 535          16,                    /* bitsize */
 536          false,                 /* pc_relative */
 537          0,                     /* bitpos */
 538          complain_overflow_dont, /* complain_on_overflow */
 539          _bfd_mips_elf_hi16_reloc,      /* special_function */
 540          "R_MIPS_HI16",         /* name */
 541          true,                  /* partial_inplace */
 542          0xffff,                /* src_mask */
 543          0xffff,                /* dst_mask */
 544          false),                /* pcrel_offset */
 545
 546   /* Low 16 bits of symbol value.  */
 547   HOWTO (R_MIPS_LO16,           /* type */
 548          0,                     /* rightshift */
 549          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 550          16,                    /* bitsize */
 551          false,                 /* pc_relative */
 552          0,                     /* bitpos */
 553          complain_overflow_dont, /* complain_on_overflow */
 554          _bfd_mips_elf_lo16_reloc,      /* special_function */
 555          "R_MIPS_LO16",         /* name */
 556          true,                  /* partial_inplace */
 557          0xffff,                /* src_mask */
 558          0xffff,                /* dst_mask */
 559          false),                /* pcrel_offset */
 560
 561   /* GP relative reference.  */
 562   HOWTO (R_MIPS_GPREL16,        /* type */
 563          0,                     /* rightshift */
 564          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 565          16,                    /* bitsize */
 566          false,                 /* pc_relative */
 567          0,                     /* bitpos */
 568          complain_overflow_signed, /* complain_on_overflow */
 569          _bfd_mips_elf_gprel16_reloc, /* special_function */
 570          "R_MIPS_GPREL16",      /* name */
 571          true,                  /* partial_inplace */
 572          0xffff,                /* src_mask */
 573          0xffff,                /* dst_mask */
 574          false),                /* pcrel_offset */
 575
 576   /* Reference to literal section.  */
 577   HOWTO (R_MIPS_LITERAL,        /* type */
 578          0,                     /* rightshift */
 579          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 580          16,                    /* bitsize */
 581          false,                 /* pc_relative */
 582          0,                     /* bitpos */
 583          complain_overflow_signed, /* complain_on_overflow */
 584          _bfd_mips_elf_gprel16_reloc, /* special_function */
 585          "R_MIPS_LITERAL",      /* name */
 586          true,                  /* partial_inplace */
 587          0xffff,                /* src_mask */
 588          0xffff,                /* dst_mask */
 589          false),                /* pcrel_offset */
 590
 591   /* Reference to global offset table.  */
 592   HOWTO (R_MIPS_GOT16,          /* type */
 593          0,                     /* rightshift */
 594          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 595          16,                    /* bitsize */
 596          false,                 /* pc_relative */
 597          0,                     /* bitpos */
 598          complain_overflow_signed, /* complain_on_overflow */
 599          _bfd_mips_elf_got16_reloc,     /* special_function */
 600          "R_MIPS_GOT16",        /* name */
 601          false,                 /* partial_inplace */
 602          0xffff,                /* src_mask */
 603          0xffff,                /* dst_mask */
 604          false),                /* pcrel_offset */
 605
 606   /* 16 bit PC relative reference.  */
 607   HOWTO (R_MIPS_PC16,           /* type */
 608          0,                     /* rightshift */
 609          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 610          16,                    /* bitsize */
 611          true,                  /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_signed, /* complain_on_overflow */
 614          bfd_elf_generic_reloc, /* special_function */
 615          "R_MIPS_PC16",         /* name */
 616          true,                  /* partial_inplace */
 617          0xffff,                /* src_mask */
 618          0xffff,                /* dst_mask */
 619          true),                 /* pcrel_offset */
 620
 621   /* 16 bit call through global offset table.  */
 622   HOWTO (R_MIPS_CALL16,         /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          16,                    /* bitsize */
 626          false,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_signed, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_MIPS_CALL16",       /* name */
 631          false,                 /* partial_inplace */
 632          0xffff,                /* src_mask */
 633          0xffff,                /* dst_mask */
 634          false),                /* pcrel_offset */
 635
 636   /* 32 bit GP relative reference.  */
 637   HOWTO (R_MIPS_GPREL32,        /* type */
 638          0,                     /* rightshift */
 639          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          32,                    /* bitsize */
 641          false,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_bitfield, /* complain_on_overflow */
 644          _bfd_mips_elf_gprel32_reloc, /* special_function */
 645          "R_MIPS_GPREL32",      /* name */
 646          true,                  /* partial_inplace */
 647          0xffffffff,            /* src_mask */
 648          0xffffffff,            /* dst_mask */
 649          false),                /* pcrel_offset */
 650
 651     /* The remaining relocs are defined on Irix 5, although they are
 652        not defined by the ABI.  */
 653     EMPTY_HOWTO (13),
 654     EMPTY_HOWTO (14),
 655     EMPTY_HOWTO (15),
 656
 657   /* A 5 bit shift field.  */
 658   HOWTO (R_MIPS_SHIFT5,         /* type */
 659          0,                     /* rightshift */
 660          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 661          5,                     /* bitsize */
 662          false,                 /* pc_relative */
 663          6,                     /* bitpos */
 664          complain_overflow_bitfield, /* complain_on_overflow */
 665          bfd_elf_generic_reloc, /* special_function */
 666          "R_MIPS_SHIFT5",       /* name */
 667          true,                  /* partial_inplace */
 668          0x000007c0,            /* src_mask */
 669          0x000007c0,            /* dst_mask */
 670          false),                /* pcrel_offset */
 671
 672   /* A 6 bit shift field.  */
 673   /* FIXME: This is not handled correctly; a special function is
 674      needed to put the most significant bit in the right place.  */
 675   HOWTO (R_MIPS_SHIFT6,         /* type */
 676          0,                     /* rightshift */
 677          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 678          6,                     /* bitsize */
 679          false,                 /* pc_relative */
 680          6,                     /* bitpos */
 681          complain_overflow_bitfield, /* complain_on_overflow */
 682          bfd_elf_generic_reloc, /* special_function */
 683          "R_MIPS_SHIFT6",       /* name */
 684          true,                  /* partial_inplace */
 685          0x000007c4,            /* src_mask */
 686          0x000007c4,            /* dst_mask */
 687          false),                /* pcrel_offset */
 688
 689   /* A 64 bit relocation.  */
 690   HOWTO (R_MIPS_64,             /* type */
 691          0,                     /* rightshift */
 692          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 693          64,                    /* bitsize */
 694          false,                 /* pc_relative */
 695          0,                     /* bitpos */
 696          complain_overflow_bitfield, /* complain_on_overflow */
 697          mips32_64bit_reloc,    /* special_function */
 698          "R_MIPS_64",           /* name */
 699          true,                  /* partial_inplace */
 700          MINUS_ONE,             /* src_mask */
 701          MINUS_ONE,             /* dst_mask */
 702          false),                /* pcrel_offset */
 703
 704   /* Displacement in the global offset table.  */
 705   HOWTO (R_MIPS_GOT_DISP,       /* type */
 706          0,                     /* rightshift */
 707          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 708          16,                    /* bitsize */
 709          false,                 /* pc_relative */
 710          0,                     /* bitpos */
 711          complain_overflow_bitfield, /* complain_on_overflow */
 712          bfd_elf_generic_reloc, /* special_function */
 713          "R_MIPS_GOT_DISP",     /* name */
 714          true,                  /* partial_inplace */
 715          0x0000ffff,            /* src_mask */
 716          0x0000ffff,            /* dst_mask */
 717          false),                /* pcrel_offset */
 718
 719   /* Displacement to page pointer in the global offset table.  */
 720   HOWTO (R_MIPS_GOT_PAGE,       /* type */
 721          0,                     /* rightshift */
 722          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 723          16,                    /* bitsize */
 724          false,                 /* pc_relative */
 725          0,                     /* bitpos */
 726          complain_overflow_bitfield, /* complain_on_overflow */
 727          bfd_elf_generic_reloc, /* special_function */
 728          "R_MIPS_GOT_PAGE",     /* name */
 729          true,                  /* partial_inplace */
 730          0x0000ffff,            /* src_mask */
 731          0x0000ffff,            /* dst_mask */
 732          false),                /* pcrel_offset */
 733
 734   /* Offset from page pointer in the global offset table.  */
 735   HOWTO (R_MIPS_GOT_OFST,       /* type */
 736          0,                     /* rightshift */
 737          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 738          16,                    /* bitsize */
 739          false,                 /* pc_relative */
 740          0,                     /* bitpos */
 741          complain_overflow_bitfield, /* complain_on_overflow */
 742          bfd_elf_generic_reloc, /* special_function */
 743          "R_MIPS_GOT_OFST",     /* name */
 744          true,                  /* partial_inplace */
 745          0x0000ffff,            /* src_mask */
 746          0x0000ffff,            /* dst_mask */
 747          false),                /* pcrel_offset */
 748
 749   /* High 16 bits of displacement in global offset table.  */
 750   HOWTO (R_MIPS_GOT_HI16,       /* type */
 751          0,                     /* rightshift */
 752          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 753          16,                    /* bitsize */
 754          false,                 /* pc_relative */
 755          0,                     /* bitpos */
 756          complain_overflow_dont, /* complain_on_overflow */
 757          bfd_elf_generic_reloc, /* special_function */
 758          "R_MIPS_GOT_HI16",     /* name */
 759          true,                  /* partial_inplace */
 760          0x0000ffff,            /* src_mask */
 761          0x0000ffff,            /* dst_mask */
 762          false),                /* pcrel_offset */
 763
 764   /* Low 16 bits of displacement in global offset table.  */
 765   HOWTO (R_MIPS_GOT_LO16,       /* type */
 766          0,                     /* rightshift */
 767          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 768          16,                    /* bitsize */
 769          false,                 /* pc_relative */
 770          0,                     /* bitpos */
 771          complain_overflow_dont, /* complain_on_overflow */
 772          bfd_elf_generic_reloc, /* special_function */
 773          "R_MIPS_GOT_LO16",     /* name */
 774          true,                  /* partial_inplace */
 775          0x0000ffff,            /* src_mask */
 776          0x0000ffff,            /* dst_mask */
 777          false),                /* pcrel_offset */
 778
 779   /* 64 bit subtraction.  Used in the N32 ABI.  */
 780   HOWTO (R_MIPS_SUB,            /* type */
 781          0,                     /* rightshift */
 782          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 783          64,                    /* bitsize */
 784          false,                 /* pc_relative */
 785          0,                     /* bitpos */
 786          complain_overflow_bitfield, /* complain_on_overflow */
 787          bfd_elf_generic_reloc, /* special_function */
 788          "R_MIPS_SUB",          /* name */
 789          true,                  /* partial_inplace */
 790          MINUS_ONE,             /* src_mask */
 791          MINUS_ONE,             /* dst_mask */
 792          false),                /* pcrel_offset */
 793
 794   /* Used to cause the linker to insert and delete instructions?  */
 795   EMPTY_HOWTO (R_MIPS_INSERT_A),
 796   EMPTY_HOWTO (R_MIPS_INSERT_B),
 797   EMPTY_HOWTO (R_MIPS_DELETE),
 798
 799   /* Get the higher value of a 64 bit addend.  */
 800   HOWTO (R_MIPS_HIGHER,         /* type */
 801          0,                     /* rightshift */
 802          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 803          16,                    /* bitsize */
 804          false,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_dont, /* complain_on_overflow */
 807          bfd_elf_generic_reloc, /* special_function */
 808          "R_MIPS_HIGHER",       /* name */
 809          true,                  /* partial_inplace */
 810          0,                     /* src_mask */
 811          0xffff,                /* dst_mask */
 812          false),                /* pcrel_offset */
 813
 814   /* Get the highest value of a 64 bit addend.  */
 815   HOWTO (R_MIPS_HIGHEST,        /* type */
 816          0,                     /* rightshift */
 817          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 818          16,                    /* bitsize */
 819          false,                 /* pc_relative */
 820          0,                     /* bitpos */
 821          complain_overflow_dont, /* complain_on_overflow */
 822          bfd_elf_generic_reloc, /* special_function */
 823          "R_MIPS_HIGHEST",      /* name */
 824          true,                  /* partial_inplace */
 825          0,                     /* src_mask */
 826          0xffff,                /* dst_mask */
 827          false),                /* pcrel_offset */
 828
 829   /* High 16 bits of displacement in global offset table.  */
 830   HOWTO (R_MIPS_CALL_HI16,      /* type */
 831          0,                     /* rightshift */
 832          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 833          16,                    /* bitsize */
 834          false,                 /* pc_relative */
 835          0,                     /* bitpos */
 836          complain_overflow_dont, /* complain_on_overflow */
 837          bfd_elf_generic_reloc, /* special_function */
 838          "R_MIPS_CALL_HI16",    /* name */
 839          true,                  /* partial_inplace */
 840          0x0000ffff,            /* src_mask */
 841          0x0000ffff,            /* dst_mask */
 842          false),                /* pcrel_offset */
 843
 844   /* Low 16 bits of displacement in global offset table.  */
 845   HOWTO (R_MIPS_CALL_LO16,      /* type */
 846          0,                     /* rightshift */
 847          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 848          16,                    /* bitsize */
 849          false,                 /* pc_relative */
 850          0,                     /* bitpos */
 851          complain_overflow_dont, /* complain_on_overflow */
 852          bfd_elf_generic_reloc, /* special_function */
 853          "R_MIPS_CALL_LO16",    /* name */
 854          true,                  /* partial_inplace */
 855          0x0000ffff,            /* src_mask */
 856          0x0000ffff,            /* dst_mask */
 857          false),                /* pcrel_offset */
 858
 859   /* Section displacement.  */
 860   HOWTO (R_MIPS_SCN_DISP,       /* type */
 861          0,                     /* rightshift */
 862          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 863          32,                    /* bitsize */
 864          false,                 /* pc_relative */
 865          0,                     /* bitpos */
 866          complain_overflow_dont, /* complain_on_overflow */
 867          bfd_elf_generic_reloc, /* special_function */
 868          "R_MIPS_SCN_DISP",     /* name */
 869          false,                 /* partial_inplace */
 870          0xffffffff,            /* src_mask */
 871          0xffffffff,            /* dst_mask */
 872          false),                /* pcrel_offset */
 873
 874   EMPTY_HOWTO (R_MIPS_REL16),
 875   EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
 876   EMPTY_HOWTO (R_MIPS_PJUMP),
 877   EMPTY_HOWTO (R_MIPS_RELGOT),
 878
 879   /* Protected jump conversion.  This is an optimization hint.  No
 880      relocation is required for correctness.  */
 881   HOWTO (R_MIPS_JALR,           /* type */
 882          0,                     /* rightshift */
 883          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 884          0,                     /* bitsize */
 885          false,                 /* pc_relative */
 886          0,                     /* bitpos */
 887          complain_overflow_dont, /* complain_on_overflow */
 888          bfd_elf_generic_reloc, /* special_function */
 889          "R_MIPS_JALR",         /* name */
 890          false,                 /* partial_inplace */
 891          0x00000000,            /* src_mask */
 892          0x00000000,            /* dst_mask */
 893          false),                /* pcrel_offset */
 894 };
 895
 896 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link.  This
 897    is a hack to make the linker think that we need 64 bit values.  */
 898 static reloc_howto_type elf_mips_ctor64_howto =
 899   HOWTO (R_MIPS_64,             /* type */
 900          0,                     /* rightshift */
 901          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 902          32,                    /* bitsize */
 903          false,                 /* pc_relative */
 904          0,                     /* bitpos */
 905          complain_overflow_signed, /* complain_on_overflow */
 906          mips32_64bit_reloc,    /* special_function */
 907          "R_MIPS_64",           /* name */
 908          true,                  /* partial_inplace */
 909          0xffffffff,            /* src_mask */
 910          0xffffffff,            /* dst_mask */
 911          false);                /* pcrel_offset */
 912
 913 /* The reloc used for the mips16 jump instruction.  */
 914 static reloc_howto_type elf_mips16_jump_howto =
 915   HOWTO (R_MIPS16_26,           /* type */
 916          2,                     /* rightshift */
 917          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 918          26,                    /* bitsize */
 919          false,                 /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_dont, /* complain_on_overflow */
 922                                 /* This needs complex overflow
 923                                    detection, because the upper four
 924                                    bits must match the PC.  */
 925          mips16_jump_reloc,     /* special_function */
 926          "R_MIPS16_26",         /* name */
 927          true,                  /* partial_inplace */
 928          0x3ffffff,             /* src_mask */
 929          0x3ffffff,             /* dst_mask */
 930          false);                /* pcrel_offset */
 931
 932 /* The reloc used for the mips16 gprel instruction.  */
 933 static reloc_howto_type elf_mips16_gprel_howto =
 934   HOWTO (R_MIPS16_GPREL,        /* type */
 935          0,                     /* rightshift */
 936          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 937          16,                    /* bitsize */
 938          false,                 /* pc_relative */
 939          0,                     /* bitpos */
 940          complain_overflow_signed, /* complain_on_overflow */
 941          mips16_gprel_reloc,    /* special_function */
 942          "R_MIPS16_GPREL",      /* name */
 943          true,                  /* partial_inplace */
 944          0x07ff001f,            /* src_mask */
 945          0x07ff001f,            /* dst_mask */
 946          false);                /* pcrel_offset */
 947
 948 /* GNU extensions for embedded-pic.  */
 949 /* High 16 bits of symbol value, pc-relative.  */
 950 static reloc_howto_type elf_mips_gnu_rel_hi16 =
 951   HOWTO (R_MIPS_GNU_REL_HI16,   /* type */
 952          0,                     /* rightshift */
 953          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 954          16,                    /* bitsize */
 955          true,                  /* pc_relative */
 956          0,                     /* bitpos */
 957          complain_overflow_dont, /* complain_on_overflow */
 958          _bfd_mips_elf_hi16_reloc,      /* special_function */
 959          "R_MIPS_GNU_REL_HI16", /* name */
 960          true,                  /* partial_inplace */
 961          0xffff,                /* src_mask */
 962          0xffff,                /* dst_mask */
 963          true);                 /* pcrel_offset */
 964
 965 /* Low 16 bits of symbol value, pc-relative.  */
 966 static reloc_howto_type elf_mips_gnu_rel_lo16 =
 967   HOWTO (R_MIPS_GNU_REL_LO16,   /* type */
 968          0,                     /* rightshift */
 969          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 970          16,                    /* bitsize */
 971          true,                  /* pc_relative */
 972          0,                     /* bitpos */
 973          complain_overflow_dont, /* complain_on_overflow */
 974          _bfd_mips_elf_lo16_reloc,      /* special_function */
 975          "R_MIPS_GNU_REL_LO16", /* name */
 976          true,                  /* partial_inplace */
 977          0xffff,                /* src_mask */
 978          0xffff,                /* dst_mask */
 979          true);                 /* pcrel_offset */
 980
 981 /* 16 bit offset for pc-relative branches.  */
 982 static reloc_howto_type elf_mips_gnu_rel16_s2 =
 983   HOWTO (R_MIPS_GNU_REL16_S2,   /* type */
 984          2,                     /* rightshift */
 985          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 986          16,                    /* bitsize */
 987          true,                  /* pc_relative */
 988          0,                     /* bitpos */
 989          complain_overflow_signed, /* complain_on_overflow */
 990          bfd_elf_generic_reloc, /* special_function */
 991          "R_MIPS_GNU_REL16_S2", /* name */
 992          true,                  /* partial_inplace */
 993          0xffff,                /* src_mask */
 994          0xffff,                /* dst_mask */
 995          true);                 /* pcrel_offset */
 996
 997 /* 64 bit pc-relative.  */
 998 static reloc_howto_type elf_mips_gnu_pcrel64 =
 999   HOWTO (R_MIPS_PC64,           /* type */
1000          0,                     /* rightshift */
1001          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1002          64,                    /* bitsize */
1003          true,                  /* pc_relative */
1004          0,                     /* bitpos */
1005          complain_overflow_signed, /* complain_on_overflow */
1006          bfd_elf_generic_reloc, /* special_function */
1007          "R_MIPS_PC64",         /* name */
1008          true,                  /* partial_inplace */
1009          MINUS_ONE,             /* src_mask */
1010          MINUS_ONE,             /* dst_mask */
1011          true);                 /* pcrel_offset */
1012
1013 /* 32 bit pc-relative.  */
1014 static reloc_howto_type elf_mips_gnu_pcrel32 =
1015   HOWTO (R_MIPS_PC32,           /* type */
1016          0,                     /* rightshift */
1017          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1018          32,                    /* bitsize */
1019          true,                  /* pc_relative */
1020          0,                     /* bitpos */
1021          complain_overflow_signed, /* complain_on_overflow */
1022          bfd_elf_generic_reloc, /* special_function */
1023          "R_MIPS_PC32",         /* name */
1024          true,                  /* partial_inplace */
1025          0xffffffff,            /* src_mask */
1026          0xffffffff,            /* dst_mask */
1027          true);                 /* pcrel_offset */
1028
1029 /* GNU extension to record C++ vtable hierarchy */
1030 static reloc_howto_type elf_mips_gnu_vtinherit_howto =
1031   HOWTO (R_MIPS_GNU_VTINHERIT,  /* type */
1032          0,                     /* rightshift */
1033          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1034          0,                     /* bitsize */
1035          false,                 /* pc_relative */
1036          0,                     /* bitpos */
1037          complain_overflow_dont, /* complain_on_overflow */
1038          NULL,                  /* special_function */
1039          "R_MIPS_GNU_VTINHERIT", /* name */
1040          false,                 /* partial_inplace */
1041          0,                     /* src_mask */
1042          0,                     /* dst_mask */
1043          false);                /* pcrel_offset */
1044
1045 /* GNU extension to record C++ vtable member usage */
1046 static reloc_howto_type elf_mips_gnu_vtentry_howto =
1047   HOWTO (R_MIPS_GNU_VTENTRY,    /* type */
1048          0,                     /* rightshift */
1049          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1050          0,                     /* bitsize */
1051          false,                 /* pc_relative */
1052          0,                     /* bitpos */
1053          complain_overflow_dont, /* complain_on_overflow */
1054          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1055          "R_MIPS_GNU_VTENTRY",  /* name */
1056          false,                 /* partial_inplace */
1057          0,                     /* src_mask */
1058          0,                     /* dst_mask */
1059          false);                /* pcrel_offset */
1060
1061 /* Do a R_MIPS_HI16 relocation.  This has to be done in combination
1062    with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
1063    the HI16.  Here we just save the information we need; we do the
1064    actual relocation when we see the LO16.  MIPS ELF requires that the
1065    LO16 immediately follow the HI16.  As a GNU extension, we permit an
1066    arbitrary number of HI16 relocs to be associated with a single LO16
1067    reloc.  This extension permits gcc to output the HI and LO relocs
1068    itself.  */
1069
1070 struct mips_hi16 {
1071   struct mips_hi16 *next;
1072   bfd_byte *addr;
1073   bfd_vma addend;
1074 };
1075
1076 /* FIXME: This should not be a static variable.  */
1077
1078 static struct mips_hi16 *mips_hi16_list;
1079
1080 bfd_reloc_status_type
1081 _bfd_mips_elf_hi16_reloc (abfd,
1082                      reloc_entry,
1083                      symbol,
1084                      data,
1085                      input_section,
1086                      output_bfd,
1087                      error_message)
1088      bfd *abfd ATTRIBUTE_UNUSED;
1089      arelent *reloc_entry;
1090      asymbol *symbol;
1091      PTR data;
1092      asection *input_section;
1093      bfd *output_bfd;
1094      char **error_message;
1095 {
1096   bfd_reloc_status_type ret;
1097   bfd_vma relocation;
1098   struct mips_hi16 *n;
1099
1100   /* If we're relocating, and this an external symbol, we don't want
1101      to change anything.  */
1102   if (output_bfd != (bfd *) NULL
1103       && (symbol->flags & BSF_SECTION_SYM) == 0
1104       && reloc_entry->addend == 0)
1105     {
1106       reloc_entry->address += input_section->output_offset;
1107       return bfd_reloc_ok;
1108     }
1109
1110   ret = bfd_reloc_ok;
1111
1112   if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1113     {
1114       boolean relocateable;
1115       bfd_vma gp;
1116
1117       if (ret == bfd_reloc_undefined)
1118         abort ();
1119
1120       if (output_bfd != NULL)
1121         relocateable = true;
1122       else
1123         {
1124           relocateable = false;
1125           output_bfd = symbol->section->output_section->owner;
1126         }
1127
1128       ret = mips_elf_final_gp (output_bfd, symbol, relocateable,
1129                                error_message, &gp);
1130       if (ret != bfd_reloc_ok)
1131         return ret;
1132
1133       relocation = gp - reloc_entry->address;
1134     }
1135   else
1136     {
1137       if (bfd_is_und_section (symbol->section)
1138           && output_bfd == (bfd *) NULL)
1139         ret = bfd_reloc_undefined;
1140
1141       if (bfd_is_com_section (symbol->section))
1142         relocation = 0;
1143       else
1144         relocation = symbol->value;
1145     }
1146
1147   relocation += symbol->section->output_section->vma;
1148   relocation += symbol->section->output_offset;
1149   relocation += reloc_entry->addend;
1150
1151   if (reloc_entry->address > input_section->_cooked_size)
1152     return bfd_reloc_outofrange;
1153
1154   /* Save the information, and let LO16 do the actual relocation.  */
1155   n = (struct mips_hi16 *) bfd_malloc (sizeof *n);
1156   if (n == NULL)
1157     return bfd_reloc_outofrange;
1158   n->addr = (bfd_byte *) data + reloc_entry->address;
1159   n->addend = relocation;
1160   n->next = mips_hi16_list;
1161   mips_hi16_list = n;
1162
1163   if (output_bfd != (bfd *) NULL)
1164     reloc_entry->address += input_section->output_offset;
1165
1166   return ret;
1167 }
1168
1169 /* Do a R_MIPS_LO16 relocation.  This is a straightforward 16 bit
1170    inplace relocation; this function exists in order to do the
1171    R_MIPS_HI16 relocation described above.  */
1172
1173 bfd_reloc_status_type
1174 _bfd_mips_elf_lo16_reloc (abfd,
1175                      reloc_entry,
1176                      symbol,
1177                      data,
1178                      input_section,
1179                      output_bfd,
1180                      error_message)
1181      bfd *abfd;
1182      arelent *reloc_entry;
1183      asymbol *symbol;
1184      PTR data;
1185      asection *input_section;
1186      bfd *output_bfd;
1187      char **error_message;
1188 {
1189   arelent gp_disp_relent;
1190
1191   if (mips_hi16_list != NULL)
1192     {
1193       struct mips_hi16 *l;
1194
1195       l = mips_hi16_list;
1196       while (l != NULL)
1197         {
1198           unsigned long insn;
1199           unsigned long val;
1200           unsigned long vallo;
1201           struct mips_hi16 *next;
1202
1203           /* Do the HI16 relocation.  Note that we actually don't need
1204              to know anything about the LO16 itself, except where to
1205              find the low 16 bits of the addend needed by the LO16.  */
1206           insn = bfd_get_32 (abfd, l->addr);
1207           vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
1208                    & 0xffff);
1209           val = ((insn & 0xffff) << 16) + vallo;
1210           val += l->addend;
1211
1212           /* The low order 16 bits are always treated as a signed
1213              value.  Therefore, a negative value in the low order bits
1214              requires an adjustment in the high order bits.  We need
1215              to make this adjustment in two ways: once for the bits we
1216              took from the data, and once for the bits we are putting
1217              back in to the data.  */
1218           if ((vallo & 0x8000) != 0)
1219             val -= 0x10000;
1220           if ((val & 0x8000) != 0)
1221             val += 0x10000;
1222
1223           insn = (insn & ~0xffff) | ((val >> 16) & 0xffff);
1224           bfd_put_32 (abfd, insn, l->addr);
1225
1226           if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1227             {
1228               gp_disp_relent = *reloc_entry;
1229               reloc_entry = &gp_disp_relent;
1230               reloc_entry->addend = l->addend;
1231             }
1232
1233           next = l->next;
1234           free (l);
1235           l = next;
1236         }
1237
1238       mips_hi16_list = NULL;
1239     }
1240   else if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1241     {
1242       bfd_reloc_status_type ret;
1243       bfd_vma gp, relocation;
1244
1245       /* FIXME: Does this case ever occur?  */
1246
1247       ret = mips_elf_final_gp (output_bfd, symbol, true, error_message, &gp);
1248       if (ret != bfd_reloc_ok)
1249         return ret;
1250
1251       relocation = gp - reloc_entry->address;
1252       relocation += symbol->section->output_section->vma;
1253       relocation += symbol->section->output_offset;
1254       relocation += reloc_entry->addend;
1255
1256       if (reloc_entry->address > input_section->_cooked_size)
1257         return bfd_reloc_outofrange;
1258
1259       gp_disp_relent = *reloc_entry;
1260       reloc_entry = &gp_disp_relent;
1261       reloc_entry->addend = relocation - 4;
1262     }
1263
1264   /* Now do the LO16 reloc in the usual way.  */
1265   return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1266                                 input_section, output_bfd, error_message);
1267 }
1268
1269 /* Do a R_MIPS_GOT16 reloc.  This is a reloc against the global offset
1270    table used for PIC code.  If the symbol is an external symbol, the
1271    instruction is modified to contain the offset of the appropriate
1272    entry in the global offset table.  If the symbol is a section
1273    symbol, the next reloc is a R_MIPS_LO16 reloc.  The two 16 bit
1274    addends are combined to form the real addend against the section
1275    symbol; the GOT16 is modified to contain the offset of an entry in
1276    the global offset table, and the LO16 is modified to offset it
1277    appropriately.  Thus an offset larger than 16 bits requires a
1278    modified value in the global offset table.
1279
1280    This implementation suffices for the assembler, but the linker does
1281    not yet know how to create global offset tables.  */
1282
1283 bfd_reloc_status_type
1284 _bfd_mips_elf_got16_reloc (abfd,
1285                       reloc_entry,
1286                       symbol,
1287                       data,
1288                       input_section,
1289                       output_bfd,
1290                       error_message)
1291      bfd *abfd;
1292      arelent *reloc_entry;
1293      asymbol *symbol;
1294      PTR data;
1295      asection *input_section;
1296      bfd *output_bfd;
1297      char **error_message;
1298 {
1299   /* If we're relocating, and this an external symbol, we don't want
1300      to change anything.  */
1301   if (output_bfd != (bfd *) NULL
1302       && (symbol->flags & BSF_SECTION_SYM) == 0
1303       && reloc_entry->addend == 0)
1304     {
1305       reloc_entry->address += input_section->output_offset;
1306       return bfd_reloc_ok;
1307     }
1308
1309   /* If we're relocating, and this is a local symbol, we can handle it
1310      just like HI16.  */
1311   if (output_bfd != (bfd *) NULL
1312       && (symbol->flags & BSF_SECTION_SYM) != 0)
1313     return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
1314                                      input_section, output_bfd, error_message);
1315
1316   abort ();
1317 }
1318
1319 /* Set the GP value for OUTPUT_BFD.  Returns false if this is a
1320    dangerous relocation.  */
1321
1322 static boolean
1323 mips_elf_assign_gp (output_bfd, pgp)
1324      bfd *output_bfd;
1325      bfd_vma *pgp;
1326 {
1327   unsigned int count;
1328   asymbol **sym;
1329   unsigned int i;
1330
1331   /* If we've already figured out what GP will be, just return it.  */
1332   *pgp = _bfd_get_gp_value (output_bfd);
1333   if (*pgp)
1334     return true;
1335
1336   count = bfd_get_symcount (output_bfd);
1337   sym = bfd_get_outsymbols (output_bfd);
1338
1339   /* The linker script will have created a symbol named `_gp' with the
1340      appropriate value.  */
1341   if (sym == (asymbol **) NULL)
1342     i = count;
1343   else
1344     {
1345       for (i = 0; i < count; i++, sym++)
1346         {
1347           register CONST char *name;
1348
1349           name = bfd_asymbol_name (*sym);
1350           if (*name == '_' && strcmp (name, "_gp") == 0)
1351             {
1352               *pgp = bfd_asymbol_value (*sym);
1353               _bfd_set_gp_value (output_bfd, *pgp);
1354               break;
1355             }
1356         }
1357     }
1358
1359   if (i >= count)
1360     {
1361       /* Only get the error once.  */
1362       *pgp = 4;
1363       _bfd_set_gp_value (output_bfd, *pgp);
1364       return false;
1365     }
1366
1367   return true;
1368 }
1369
1370 /* We have to figure out the gp value, so that we can adjust the
1371    symbol value correctly.  We look up the symbol _gp in the output
1372    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
1373    target data.  We don't need to adjust the symbol value for an
1374    external symbol if we are producing relocateable output.  */
1375
1376 static bfd_reloc_status_type
1377 mips_elf_final_gp (output_bfd, symbol, relocateable, error_message, pgp)
1378      bfd *output_bfd;
1379      asymbol *symbol;
1380      boolean relocateable;
1381      char **error_message;
1382      bfd_vma *pgp;
1383 {
1384   if (bfd_is_und_section (symbol->section)
1385       && ! relocateable)
1386     {
1387       *pgp = 0;
1388       return bfd_reloc_undefined;
1389     }
1390
1391   *pgp = _bfd_get_gp_value (output_bfd);
1392   if (*pgp == 0
1393       && (! relocateable
1394           || (symbol->flags & BSF_SECTION_SYM) != 0))
1395     {
1396       if (relocateable)
1397         {
1398           /* Make up a value.  */
1399           *pgp = symbol->section->output_section->vma + 0x4000;
1400           _bfd_set_gp_value (output_bfd, *pgp);
1401         }
1402       else if (!mips_elf_assign_gp (output_bfd, pgp))
1403         {
1404           *error_message =
1405             (char *) _("GP relative relocation when _gp not defined");
1406           return bfd_reloc_dangerous;
1407         }
1408     }
1409
1410   return bfd_reloc_ok;
1411 }
1412
1413 /* Do a R_MIPS_GPREL16 relocation.  This is a 16 bit value which must
1414    become the offset from the gp register.  This function also handles
1415    R_MIPS_LITERAL relocations, although those can be handled more
1416    cleverly because the entries in the .lit8 and .lit4 sections can be
1417    merged.  */
1418
1419 static bfd_reloc_status_type gprel16_with_gp PARAMS ((bfd *, asymbol *,
1420                                                       arelent *, asection *,
1421                                                       boolean, PTR, bfd_vma));
1422
1423 bfd_reloc_status_type
1424 _bfd_mips_elf_gprel16_reloc (abfd, reloc_entry, symbol, data, input_section,
1425                              output_bfd, error_message)
1426      bfd *abfd;
1427      arelent *reloc_entry;
1428      asymbol *symbol;
1429      PTR data;
1430      asection *input_section;
1431      bfd *output_bfd;
1432      char **error_message;
1433 {
1434   boolean relocateable;
1435   bfd_reloc_status_type ret;
1436   bfd_vma gp;
1437
1438   /* If we're relocating, and this is an external symbol with no
1439      addend, we don't want to change anything.  We will only have an
1440      addend if this is a newly created reloc, not read from an ELF
1441      file.  */
1442   if (output_bfd != (bfd *) NULL
1443       && (symbol->flags & BSF_SECTION_SYM) == 0
1444       && reloc_entry->addend == 0)
1445     {
1446       reloc_entry->address += input_section->output_offset;
1447       return bfd_reloc_ok;
1448     }
1449
1450   if (output_bfd != (bfd *) NULL)
1451     relocateable = true;
1452   else
1453     {
1454       relocateable = false;
1455       output_bfd = symbol->section->output_section->owner;
1456     }
1457
1458   ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1459                            &gp);
1460   if (ret != bfd_reloc_ok)
1461     return ret;
1462
1463   return gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1464                           relocateable, data, gp);
1465 }
1466
1467 static bfd_reloc_status_type
1468 gprel16_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1469                  gp)
1470      bfd *abfd;
1471      asymbol *symbol;
1472      arelent *reloc_entry;
1473      asection *input_section;
1474      boolean relocateable;
1475      PTR data;
1476      bfd_vma gp;
1477 {
1478   bfd_vma relocation;
1479   unsigned long insn;
1480   unsigned long val;
1481
1482   if (bfd_is_com_section (symbol->section))
1483     relocation = 0;
1484   else
1485     relocation = symbol->value;
1486
1487   relocation += symbol->section->output_section->vma;
1488   relocation += symbol->section->output_offset;
1489
1490   if (reloc_entry->address > input_section->_cooked_size)
1491     return bfd_reloc_outofrange;
1492
1493   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1494
1495   /* Set val to the offset into the section or symbol.  */
1496   if (reloc_entry->howto->src_mask == 0)
1497     {
1498       /* This case occurs with the 64-bit MIPS ELF ABI.  */
1499       val = reloc_entry->addend;
1500     }
1501   else
1502     {
1503       val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
1504       if (val & 0x8000)
1505         val -= 0x10000;
1506     }
1507
1508   /* Adjust val for the final section location and GP value.  If we
1509      are producing relocateable output, we don't want to do this for
1510      an external symbol.  */
1511   if (! relocateable
1512       || (symbol->flags & BSF_SECTION_SYM) != 0)
1513     val += relocation - gp;
1514
1515   insn = (insn & ~0xffff) | (val & 0xffff);
1516   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
1517
1518   if (relocateable)
1519     reloc_entry->address += input_section->output_offset;
1520
1521   /* Make sure it fit in 16 bits.  */
1522   if ((long) val >= 0x8000 || (long) val < -0x8000)
1523     return bfd_reloc_overflow;
1524
1525   return bfd_reloc_ok;
1526 }
1527
1528 /* Do a R_MIPS_GPREL32 relocation.  Is this 32 bit value the offset
1529    from the gp register? XXX */
1530
1531 static bfd_reloc_status_type gprel32_with_gp PARAMS ((bfd *, asymbol *,
1532                                                       arelent *, asection *,
1533                                                       boolean, PTR, bfd_vma));
1534
1535 bfd_reloc_status_type
1536 _bfd_mips_elf_gprel32_reloc (abfd,
1537                         reloc_entry,
1538                         symbol,
1539                         data,
1540                         input_section,
1541                         output_bfd,
1542                         error_message)
1543      bfd *abfd;
1544      arelent *reloc_entry;
1545      asymbol *symbol;
1546      PTR data;
1547      asection *input_section;
1548      bfd *output_bfd;
1549      char **error_message;
1550 {
1551   boolean relocateable;
1552   bfd_reloc_status_type ret;
1553   bfd_vma gp;
1554
1555   /* If we're relocating, and this is an external symbol with no
1556      addend, we don't want to change anything.  We will only have an
1557      addend if this is a newly created reloc, not read from an ELF
1558      file.  */
1559   if (output_bfd != (bfd *) NULL
1560       && (symbol->flags & BSF_SECTION_SYM) == 0
1561       && reloc_entry->addend == 0)
1562     {
1563       *error_message = (char *)
1564         _("32bits gp relative relocation occurs for an external symbol");
1565       return bfd_reloc_outofrange;
1566     }
1567
1568   if (output_bfd != (bfd *) NULL)
1569     {
1570       relocateable = true;
1571       gp = _bfd_get_gp_value (output_bfd);
1572     }
1573   else
1574     {
1575       relocateable = false;
1576       output_bfd = symbol->section->output_section->owner;
1577
1578       ret = mips_elf_final_gp (output_bfd, symbol, relocateable,
1579                                error_message, &gp);
1580       if (ret != bfd_reloc_ok)
1581         return ret;
1582     }
1583
1584   return gprel32_with_gp (abfd, symbol, reloc_entry, input_section,
1585                           relocateable, data, gp);
1586 }
1587
1588 static bfd_reloc_status_type
1589 gprel32_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1590                  gp)
1591      bfd *abfd;
1592      asymbol *symbol;
1593      arelent *reloc_entry;
1594      asection *input_section;
1595      boolean relocateable;
1596      PTR data;
1597      bfd_vma gp;
1598 {
1599   bfd_vma relocation;
1600   unsigned long val;
1601
1602   if (bfd_is_com_section (symbol->section))
1603     relocation = 0;
1604   else
1605     relocation = symbol->value;
1606
1607   relocation += symbol->section->output_section->vma;
1608   relocation += symbol->section->output_offset;
1609
1610   if (reloc_entry->address > input_section->_cooked_size)
1611     return bfd_reloc_outofrange;
1612
1613   if (reloc_entry->howto->src_mask == 0)
1614     {
1615       /* This case arises with the 64-bit MIPS ELF ABI.  */
1616       val = 0;
1617     }
1618   else
1619     val = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1620
1621   /* Set val to the offset into the section or symbol.  */
1622   val += reloc_entry->addend;
1623
1624   /* Adjust val for the final section location and GP value.  If we
1625      are producing relocateable output, we don't want to do this for
1626      an external symbol.  */
1627   if (! relocateable
1628       || (symbol->flags & BSF_SECTION_SYM) != 0)
1629     val += relocation - gp;
1630
1631   bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
1632
1633   if (relocateable)
1634     reloc_entry->address += input_section->output_offset;
1635
1636   return bfd_reloc_ok;
1637 }
1638
1639 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file.  These are
1640    generated when addreses are 64 bits.  The upper 32 bits are a simle
1641    sign extension.  */
1642
1643 static bfd_reloc_status_type
1644 mips32_64bit_reloc (abfd, reloc_entry, symbol, data, input_section,
1645                     output_bfd, error_message)
1646      bfd *abfd;
1647      arelent *reloc_entry;
1648      asymbol *symbol;
1649      PTR data;
1650      asection *input_section;
1651      bfd *output_bfd;
1652      char **error_message;
1653 {
1654   bfd_reloc_status_type r;
1655   arelent reloc32;
1656   unsigned long val;
1657   bfd_size_type addr;
1658
1659   r = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1660                              input_section, output_bfd, error_message);
1661   if (r != bfd_reloc_continue)
1662     return r;
1663
1664   /* Do a normal 32 bit relocation on the lower 32 bits.  */
1665   reloc32 = *reloc_entry;
1666   if (bfd_big_endian (abfd))
1667     reloc32.address += 4;
1668   reloc32.howto = &elf_mips_howto_table[R_MIPS_32];
1669   r = bfd_perform_relocation (abfd, &reloc32, data, input_section,
1670                               output_bfd, error_message);
1671
1672   /* Sign extend into the upper 32 bits.  */
1673   val = bfd_get_32 (abfd, (bfd_byte *) data + reloc32.address);
1674   if ((val & 0x80000000) != 0)
1675     val = 0xffffffff;
1676   else
1677     val = 0;
1678   addr = reloc_entry->address;
1679   if (bfd_little_endian (abfd))
1680     addr += 4;
1681   bfd_put_32 (abfd, val, (bfd_byte *) data + addr);
1682
1683   return r;
1684 }
1685
1686 /* Handle a mips16 jump.  */
1687
1688 static bfd_reloc_status_type
1689 mips16_jump_reloc (abfd, reloc_entry, symbol, data, input_section,
1690                    output_bfd, error_message)
1691      bfd *abfd ATTRIBUTE_UNUSED;
1692      arelent *reloc_entry;
1693      asymbol *symbol;
1694      PTR data ATTRIBUTE_UNUSED;
1695      asection *input_section;
1696      bfd *output_bfd;
1697      char **error_message ATTRIBUTE_UNUSED;
1698 {
1699   if (output_bfd != (bfd *) NULL
1700       && (symbol->flags & BSF_SECTION_SYM) == 0
1701       && reloc_entry->addend == 0)
1702     {
1703       reloc_entry->address += input_section->output_offset;
1704       return bfd_reloc_ok;
1705     }
1706
1707   /* FIXME.  */
1708   {
1709     static boolean warned;
1710
1711     if (! warned)
1712       (*_bfd_error_handler)
1713         (_("Linking mips16 objects into %s format is not supported"),
1714          bfd_get_target (input_section->output_section->owner));
1715     warned = true;
1716   }
1717
1718   return bfd_reloc_undefined;
1719 }
1720
1721 /* Handle a mips16 GP relative reloc.  */
1722
1723 static bfd_reloc_status_type
1724 mips16_gprel_reloc (abfd, reloc_entry, symbol, data, input_section,
1725                     output_bfd, error_message)
1726      bfd *abfd;
1727      arelent *reloc_entry;
1728      asymbol *symbol;
1729      PTR data;
1730      asection *input_section;
1731      bfd *output_bfd;
1732      char **error_message;
1733 {
1734   boolean relocateable;
1735   bfd_reloc_status_type ret;
1736   bfd_vma gp;
1737   unsigned short extend, insn;
1738   unsigned long final;
1739
1740   /* If we're relocating, and this is an external symbol with no
1741      addend, we don't want to change anything.  We will only have an
1742      addend if this is a newly created reloc, not read from an ELF
1743      file.  */
1744   if (output_bfd != NULL
1745       && (symbol->flags & BSF_SECTION_SYM) == 0
1746       && reloc_entry->addend == 0)
1747     {
1748       reloc_entry->address += input_section->output_offset;
1749       return bfd_reloc_ok;
1750     }
1751
1752   if (output_bfd != NULL)
1753     relocateable = true;
1754   else
1755     {
1756       relocateable = false;
1757       output_bfd = symbol->section->output_section->owner;
1758     }
1759
1760   ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1761                            &gp);
1762   if (ret != bfd_reloc_ok)
1763     return ret;
1764
1765   if (reloc_entry->address > input_section->_cooked_size)
1766     return bfd_reloc_outofrange;
1767
1768   /* Pick up the mips16 extend instruction and the real instruction.  */
1769   extend = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address);
1770   insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address + 2);
1771
1772   /* Stuff the current addend back as a 32 bit value, do the usual
1773      relocation, and then clean up.  */
1774   bfd_put_32 (abfd,
1775               (((extend & 0x1f) << 11)
1776                | (extend & 0x7e0)
1777                | (insn & 0x1f)),
1778               (bfd_byte *) data + reloc_entry->address);
1779
1780   ret = gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1781                          relocateable, data, gp);
1782
1783   final = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1784   bfd_put_16 (abfd,
1785               ((extend & 0xf800)
1786                | ((final >> 11) & 0x1f)
1787                | (final & 0x7e0)),
1788               (bfd_byte *) data + reloc_entry->address);
1789   bfd_put_16 (abfd,
1790               ((insn & 0xffe0)
1791                | (final & 0x1f)),
1792               (bfd_byte *) data + reloc_entry->address + 2);
1793
1794   return ret;
1795 }
1796
1797 /* Return the ISA for a MIPS e_flags value.  */
1798
1799 static INLINE int
1800 elf_mips_isa (flags)
1801      flagword flags;
1802 {
1803   switch (flags & EF_MIPS_ARCH)
1804     {
1805     case E_MIPS_ARCH_1:
1806       return 1;
1807     case E_MIPS_ARCH_2:
1808       return 2;
1809     case E_MIPS_ARCH_3:
1810       return 3;
1811     case E_MIPS_ARCH_4:
1812       return 4;
1813     case E_MIPS_ARCH_5:
1814       return 5;
1815     case E_MIPS_ARCH_32:
1816       return 32;
1817     case E_MIPS_ARCH_64:
1818       return 64;
1819     }
1820   return 4;
1821 }
1822
1823 /* Return the MACH for a MIPS e_flags value.  */
1824
1825 static INLINE int
1826 elf_mips_mach (flags)
1827      flagword flags;
1828 {
1829   switch (flags & EF_MIPS_MACH)
1830     {
1831     case E_MIPS_MACH_3900:
1832       return bfd_mach_mips3900;
1833
1834     case E_MIPS_MACH_4010:
1835       return bfd_mach_mips4010;
1836
1837     case E_MIPS_MACH_4100:
1838       return bfd_mach_mips4100;
1839
1840     case E_MIPS_MACH_4111:
1841       return bfd_mach_mips4111;
1842
1843     case E_MIPS_MACH_4650:
1844       return bfd_mach_mips4650;
1845
1846     case E_MIPS_MACH_MIPS32_4K:
1847       return bfd_mach_mips32_4k;
1848
1849     case E_MIPS_MACH_SB1:
1850       return bfd_mach_mips_sb1;
1851
1852     default:
1853       switch (flags & EF_MIPS_ARCH)
1854         {
1855         default:
1856         case E_MIPS_ARCH_1:
1857           return bfd_mach_mips3000;
1858           break;
1859
1860         case E_MIPS_ARCH_2:
1861           return bfd_mach_mips6000;
1862           break;
1863
1864         case E_MIPS_ARCH_3:
1865           return bfd_mach_mips4000;
1866           break;
1867
1868         case E_MIPS_ARCH_4:
1869           return bfd_mach_mips8000;
1870           break;
1871
1872         case E_MIPS_ARCH_5:
1873           return bfd_mach_mips5;
1874           break;
1875
1876         case E_MIPS_ARCH_32:
1877           return bfd_mach_mips32;
1878           break;
1879
1880         case E_MIPS_ARCH_64:
1881           return bfd_mach_mips64;
1882           break;
1883         }
1884     }
1885
1886   return 0;
1887 }
1888
1889 /* Return printable name for ABI.  */
1890
1891 static INLINE char *
1892 elf_mips_abi_name (abfd)
1893      bfd *abfd;
1894 {
1895   flagword flags;
1896
1897   if (ABI_N32_P (abfd))
1898     return "N32";
1899   else if (ABI_64_P (abfd))
1900     return "64";
1901
1902   flags = elf_elfheader (abfd)->e_flags;
1903   switch (flags & EF_MIPS_ABI)
1904     {
1905     case 0:
1906       return "none";
1907     case E_MIPS_ABI_O32:
1908       return "O32";
1909     case E_MIPS_ABI_O64:
1910       return "O64";
1911     case E_MIPS_ABI_EABI32:
1912       return "EABI32";
1913     case E_MIPS_ABI_EABI64:
1914       return "EABI64";
1915     default:
1916       return "unknown abi";
1917     }
1918 }
1919
1920 /* A mapping from BFD reloc types to MIPS ELF reloc types.  */
1921
1922 struct elf_reloc_map {
1923   bfd_reloc_code_real_type bfd_reloc_val;
1924   enum elf_mips_reloc_type elf_reloc_val;
1925 };
1926
1927 static CONST struct elf_reloc_map mips_reloc_map[] = {
1928   { BFD_RELOC_NONE, R_MIPS_NONE, },
1929   { BFD_RELOC_16, R_MIPS_16 },
1930   { BFD_RELOC_32, R_MIPS_32 },
1931   { BFD_RELOC_64, R_MIPS_64 },
1932   { BFD_RELOC_MIPS_JMP, R_MIPS_26 },
1933   { BFD_RELOC_HI16_S, R_MIPS_HI16 },
1934   { BFD_RELOC_LO16, R_MIPS_LO16 },
1935   { BFD_RELOC_MIPS_GPREL, R_MIPS_GPREL16 },
1936   { BFD_RELOC_MIPS_LITERAL, R_MIPS_LITERAL },
1937   { BFD_RELOC_MIPS_GOT16, R_MIPS_GOT16 },
1938   { BFD_RELOC_16_PCREL, R_MIPS_PC16 },
1939   { BFD_RELOC_MIPS_CALL16, R_MIPS_CALL16 },
1940   { BFD_RELOC_MIPS_GPREL32, R_MIPS_GPREL32 },
1941   { BFD_RELOC_MIPS_GOT_HI16, R_MIPS_GOT_HI16 },
1942   { BFD_RELOC_MIPS_GOT_LO16, R_MIPS_GOT_LO16 },
1943   { BFD_RELOC_MIPS_CALL_HI16, R_MIPS_CALL_HI16 },
1944   { BFD_RELOC_MIPS_CALL_LO16, R_MIPS_CALL_LO16 },
1945   { BFD_RELOC_MIPS_SUB, R_MIPS_SUB },
1946   { BFD_RELOC_MIPS_GOT_PAGE, R_MIPS_GOT_PAGE },
1947   { BFD_RELOC_MIPS_GOT_OFST, R_MIPS_GOT_OFST },
1948   { BFD_RELOC_MIPS_GOT_DISP, R_MIPS_GOT_DISP }
1949 };
1950
1951 /* Given a BFD reloc type, return a howto structure.  */
1952
1953 static reloc_howto_type *
1954 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
1955      bfd *abfd;
1956      bfd_reloc_code_real_type code;
1957 {
1958   unsigned int i;
1959
1960   for (i = 0; i < sizeof (mips_reloc_map) / sizeof (struct elf_reloc_map); i++)
1961     {
1962       if (mips_reloc_map[i].bfd_reloc_val == code)
1963         return &elf_mips_howto_table[(int) mips_reloc_map[i].elf_reloc_val];
1964     }
1965
1966   switch (code)
1967     {
1968     default:
1969       bfd_set_error (bfd_error_bad_value);
1970       return NULL;
1971
1972     case BFD_RELOC_CTOR:
1973       /* We need to handle BFD_RELOC_CTOR specially.
1974          Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1975          size of addresses on this architecture.  */
1976       if (bfd_arch_bits_per_address (abfd) == 32)
1977         return &elf_mips_howto_table[(int) R_MIPS_32];
1978       else
1979         return &elf_mips_ctor64_howto;
1980
1981     case BFD_RELOC_MIPS16_JMP:
1982       return &elf_mips16_jump_howto;
1983     case BFD_RELOC_MIPS16_GPREL:
1984       return &elf_mips16_gprel_howto;
1985     case BFD_RELOC_VTABLE_INHERIT:
1986       return &elf_mips_gnu_vtinherit_howto;
1987     case BFD_RELOC_VTABLE_ENTRY:
1988       return &elf_mips_gnu_vtentry_howto;
1989     case BFD_RELOC_PCREL_HI16_S:
1990       return &elf_mips_gnu_rel_hi16;
1991     case BFD_RELOC_PCREL_LO16:
1992       return &elf_mips_gnu_rel_lo16;
1993     case BFD_RELOC_16_PCREL_S2:
1994       return &elf_mips_gnu_rel16_s2;
1995     case BFD_RELOC_64_PCREL:
1996       return &elf_mips_gnu_pcrel64;
1997     case BFD_RELOC_32_PCREL:
1998       return &elf_mips_gnu_pcrel32;
1999     }
2000 }
2001
2002 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure.  */
2003
2004 static reloc_howto_type *
2005 mips_rtype_to_howto (r_type)
2006      unsigned int r_type;
2007 {
2008   switch (r_type)
2009     {
2010     case R_MIPS16_26:
2011       return &elf_mips16_jump_howto;
2012       break;
2013     case R_MIPS16_GPREL:
2014       return &elf_mips16_gprel_howto;
2015       break;
2016     case R_MIPS_GNU_VTINHERIT:
2017       return &elf_mips_gnu_vtinherit_howto;
2018       break;
2019     case R_MIPS_GNU_VTENTRY:
2020       return &elf_mips_gnu_vtentry_howto;
2021       break;
2022     case R_MIPS_GNU_REL_HI16:
2023       return &elf_mips_gnu_rel_hi16;
2024       break;
2025     case R_MIPS_GNU_REL_LO16:
2026       return &elf_mips_gnu_rel_lo16;
2027       break;
2028     case R_MIPS_GNU_REL16_S2:
2029       return &elf_mips_gnu_rel16_s2;
2030       break;
2031     case R_MIPS_PC64:
2032       return &elf_mips_gnu_pcrel64;
2033       break;
2034     case R_MIPS_PC32:
2035       return &elf_mips_gnu_pcrel32;
2036       break;
2037
2038     default:
2039       BFD_ASSERT (r_type < (unsigned int) R_MIPS_max);
2040       return &elf_mips_howto_table[r_type];
2041       break;
2042     }
2043 }
2044
2045 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure.  */
2046
2047 static void
2048 mips_info_to_howto_rel (abfd, cache_ptr, dst)
2049      bfd *abfd;
2050      arelent *cache_ptr;
2051      Elf32_Internal_Rel *dst;
2052 {
2053   unsigned int r_type;
2054
2055   r_type = ELF32_R_TYPE (dst->r_info);
2056   cache_ptr->howto = mips_rtype_to_howto (r_type);
2057
2058   /* The addend for a GPREL16 or LITERAL relocation comes from the GP
2059      value for the object file.  We get the addend now, rather than
2060      when we do the relocation, because the symbol manipulations done
2061      by the linker may cause us to lose track of the input BFD.  */
2062   if (((*cache_ptr->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
2063       && (r_type == (unsigned int) R_MIPS_GPREL16
2064           || r_type == (unsigned int) R_MIPS_LITERAL))
2065     cache_ptr->addend = elf_gp (abfd);
2066 }
2067
2068 /* Given a MIPS Elf32_Internal_Rela, fill in an arelent structure.  */
2069
2070 static void
2071 mips_info_to_howto_rela (abfd, cache_ptr, dst)
2072      bfd *abfd;
2073      arelent *cache_ptr;
2074      Elf32_Internal_Rela *dst;
2075 {
2076   /* Since an Elf32_Internal_Rel is an initial prefix of an
2077      Elf32_Internal_Rela, we can just use mips_info_to_howto_rel
2078      above.  */
2079   mips_info_to_howto_rel (abfd, cache_ptr, (Elf32_Internal_Rel *) dst);
2080
2081   /* If we ever need to do any extra processing with dst->r_addend
2082      (the field omitted in an Elf32_Internal_Rel) we can do it here.  */
2083 }
2084 \f
2085 /* A .reginfo section holds a single Elf32_RegInfo structure.  These
2086    routines swap this structure in and out.  They are used outside of
2087    BFD, so they are globally visible.  */
2088
2089 void
2090 bfd_mips_elf32_swap_reginfo_in (abfd, ex, in)
2091      bfd *abfd;
2092      const Elf32_External_RegInfo *ex;
2093      Elf32_RegInfo *in;
2094 {
2095   in->ri_gprmask = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gprmask);
2096   in->ri_cprmask[0] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[0]);
2097   in->ri_cprmask[1] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[1]);
2098   in->ri_cprmask[2] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[2]);
2099   in->ri_cprmask[3] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[3]);
2100   in->ri_gp_value = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gp_value);
2101 }
2102
2103 void
2104 bfd_mips_elf32_swap_reginfo_out (abfd, in, ex)
2105      bfd *abfd;
2106      const Elf32_RegInfo *in;
2107      Elf32_External_RegInfo *ex;
2108 {
2109   bfd_h_put_32 (abfd, (bfd_vma) in->ri_gprmask,
2110                 (bfd_byte *) ex->ri_gprmask);
2111   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[0],
2112                 (bfd_byte *) ex->ri_cprmask[0]);
2113   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[1],
2114                 (bfd_byte *) ex->ri_cprmask[1]);
2115   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[2],
2116                 (bfd_byte *) ex->ri_cprmask[2]);
2117   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[3],
2118                 (bfd_byte *) ex->ri_cprmask[3]);
2119   bfd_h_put_32 (abfd, (bfd_vma) in->ri_gp_value,
2120                 (bfd_byte *) ex->ri_gp_value);
2121 }
2122
2123 /* In the 64 bit ABI, the .MIPS.options section holds register
2124    information in an Elf64_Reginfo structure.  These routines swap
2125    them in and out.  They are globally visible because they are used
2126    outside of BFD.  These routines are here so that gas can call them
2127    without worrying about whether the 64 bit ABI has been included.  */
2128
2129 void
2130 bfd_mips_elf64_swap_reginfo_in (abfd, ex, in)
2131      bfd *abfd;
2132      const Elf64_External_RegInfo *ex;
2133      Elf64_Internal_RegInfo *in;
2134 {
2135   in->ri_gprmask = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gprmask);
2136   in->ri_pad = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_pad);
2137   in->ri_cprmask[0] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[0]);
2138   in->ri_cprmask[1] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[1]);
2139   in->ri_cprmask[2] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[2]);
2140   in->ri_cprmask[3] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[3]);
2141   in->ri_gp_value = bfd_h_get_64 (abfd, (bfd_byte *) ex->ri_gp_value);
2142 }
2143
2144 void
2145 bfd_mips_elf64_swap_reginfo_out (abfd, in, ex)
2146      bfd *abfd;
2147      const Elf64_Internal_RegInfo *in;
2148      Elf64_External_RegInfo *ex;
2149 {
2150   bfd_h_put_32 (abfd, (bfd_vma) in->ri_gprmask,
2151                 (bfd_byte *) ex->ri_gprmask);
2152   bfd_h_put_32 (abfd, (bfd_vma) in->ri_pad,
2153                 (bfd_byte *) ex->ri_pad);
2154   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[0],
2155                 (bfd_byte *) ex->ri_cprmask[0]);
2156   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[1],
2157                 (bfd_byte *) ex->ri_cprmask[1]);
2158   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[2],
2159                 (bfd_byte *) ex->ri_cprmask[2]);
2160   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[3],
2161                 (bfd_byte *) ex->ri_cprmask[3]);
2162   bfd_h_put_64 (abfd, (bfd_vma) in->ri_gp_value,
2163                 (bfd_byte *) ex->ri_gp_value);
2164 }
2165
2166 /* Swap an entry in a .gptab section.  Note that these routines rely
2167    on the equivalence of the two elements of the union.  */
2168
2169 static void
2170 bfd_mips_elf32_swap_gptab_in (abfd, ex, in)
2171      bfd *abfd;
2172      const Elf32_External_gptab *ex;
2173      Elf32_gptab *in;
2174 {
2175   in->gt_entry.gt_g_value = bfd_h_get_32 (abfd, ex->gt_entry.gt_g_value);
2176   in->gt_entry.gt_bytes = bfd_h_get_32 (abfd, ex->gt_entry.gt_bytes);
2177 }
2178
2179 static void
2180 bfd_mips_elf32_swap_gptab_out (abfd, in, ex)
2181      bfd *abfd;
2182      const Elf32_gptab *in;
2183      Elf32_External_gptab *ex;
2184 {
2185   bfd_h_put_32 (abfd, (bfd_vma) in->gt_entry.gt_g_value,
2186                 ex->gt_entry.gt_g_value);
2187   bfd_h_put_32 (abfd, (bfd_vma) in->gt_entry.gt_bytes,
2188                 ex->gt_entry.gt_bytes);
2189 }
2190
2191 static void
2192 bfd_elf32_swap_compact_rel_out (abfd, in, ex)
2193      bfd *abfd;
2194      const Elf32_compact_rel *in;
2195      Elf32_External_compact_rel *ex;
2196 {
2197   bfd_h_put_32 (abfd, (bfd_vma) in->id1, ex->id1);
2198   bfd_h_put_32 (abfd, (bfd_vma) in->num, ex->num);
2199   bfd_h_put_32 (abfd, (bfd_vma) in->id2, ex->id2);
2200   bfd_h_put_32 (abfd, (bfd_vma) in->offset, ex->offset);
2201   bfd_h_put_32 (abfd, (bfd_vma) in->reserved0, ex->reserved0);
2202   bfd_h_put_32 (abfd, (bfd_vma) in->reserved1, ex->reserved1);
2203 }
2204
2205 static void
2206 bfd_elf32_swap_crinfo_out (abfd, in, ex)
2207      bfd *abfd;
2208      const Elf32_crinfo *in;
2209      Elf32_External_crinfo *ex;
2210 {
2211   unsigned long l;
2212
2213   l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2214        | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2215        | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2216        | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2217   bfd_h_put_32 (abfd, (bfd_vma) l, ex->info);
2218   bfd_h_put_32 (abfd, (bfd_vma) in->konst, ex->konst);
2219   bfd_h_put_32 (abfd, (bfd_vma) in->vaddr, ex->vaddr);
2220 }
2221
2222 /* Swap in an options header.  */
2223
2224 void
2225 bfd_mips_elf_swap_options_in (abfd, ex, in)
2226      bfd *abfd;
2227      const Elf_External_Options *ex;
2228      Elf_Internal_Options *in;
2229 {
2230   in->kind = bfd_h_get_8 (abfd, ex->kind);
2231   in->size = bfd_h_get_8 (abfd, ex->size);
2232   in->section = bfd_h_get_16 (abfd, ex->section);
2233   in->info = bfd_h_get_32 (abfd, ex->info);
2234 }
2235
2236 /* Swap out an options header.  */
2237
2238 void
2239 bfd_mips_elf_swap_options_out (abfd, in, ex)
2240      bfd *abfd;
2241      const Elf_Internal_Options *in;
2242      Elf_External_Options *ex;
2243 {
2244   bfd_h_put_8 (abfd, in->kind, ex->kind);
2245   bfd_h_put_8 (abfd, in->size, ex->size);
2246   bfd_h_put_16 (abfd, in->section, ex->section);
2247   bfd_h_put_32 (abfd, in->info, ex->info);
2248 }
2249 #if 0
2250 /* Swap in an MSYM entry.  */
2251
2252 static void
2253 bfd_mips_elf_swap_msym_in (abfd, ex, in)
2254      bfd *abfd;
2255      const Elf32_External_Msym *ex;
2256      Elf32_Internal_Msym *in;
2257 {
2258   in->ms_hash_value = bfd_h_get_32 (abfd, ex->ms_hash_value);
2259   in->ms_info = bfd_h_get_32 (abfd, ex->ms_info);
2260 }
2261 #endif
2262 /* Swap out an MSYM entry.  */
2263
2264 static void
2265 bfd_mips_elf_swap_msym_out (abfd, in, ex)
2266      bfd *abfd;
2267      const Elf32_Internal_Msym *in;
2268      Elf32_External_Msym *ex;
2269 {
2270   bfd_h_put_32 (abfd, in->ms_hash_value, ex->ms_hash_value);
2271   bfd_h_put_32 (abfd, in->ms_info, ex->ms_info);
2272 }
2273 \f
2274 /* Determine whether a symbol is global for the purposes of splitting
2275    the symbol table into global symbols and local symbols.  At least
2276    on Irix 5, this split must be between section symbols and all other
2277    symbols.  On most ELF targets the split is between static symbols
2278    and externally visible symbols.  */
2279
2280 static boolean
2281 mips_elf_sym_is_global (abfd, sym)
2282      bfd *abfd ATTRIBUTE_UNUSED;
2283      asymbol *sym;
2284 {
2285   return (sym->flags & BSF_SECTION_SYM) == 0 ? true : false;
2286 }
2287 \f
2288 /* Set the right machine number for a MIPS ELF file.  This is used for
2289    both the 32-bit and the 64-bit ABI.  */
2290
2291 boolean
2292 _bfd_mips_elf_object_p (abfd)
2293      bfd *abfd;
2294 {
2295   /* Irix 5 and 6 is broken.  Object file symbol tables are not always
2296      sorted correctly such that local symbols precede global symbols,
2297      and the sh_info field in the symbol table is not always right.  */
2298   elf_bad_symtab (abfd) = true;
2299
2300   bfd_default_set_arch_mach (abfd, bfd_arch_mips,
2301                              elf_mips_mach (elf_elfheader (abfd)->e_flags));
2302   return true;
2303 }
2304
2305 /* The final processing done just before writing out a MIPS ELF object
2306    file.  This gets the MIPS architecture right based on the machine
2307    number.  This is used by both the 32-bit and the 64-bit ABI.  */
2308
2309 void
2310 _bfd_mips_elf_final_write_processing (abfd, linker)
2311      bfd *abfd;
2312      boolean linker ATTRIBUTE_UNUSED;
2313 {
2314   unsigned long val;
2315   unsigned int i;
2316   Elf_Internal_Shdr **hdrpp;
2317   const char *name;
2318   asection *sec;
2319
2320   switch (bfd_get_mach (abfd))
2321     {
2322     default:
2323     case bfd_mach_mips3000:
2324       val = E_MIPS_ARCH_1;
2325       break;
2326
2327     case bfd_mach_mips3900:
2328       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
2329       break;
2330
2331     case bfd_mach_mips6000:
2332       val = E_MIPS_ARCH_2;
2333       break;
2334
2335     case bfd_mach_mips4000:
2336     case bfd_mach_mips4300:
2337       val = E_MIPS_ARCH_3;
2338       break;
2339
2340     case bfd_mach_mips4010:
2341       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
2342       break;
2343
2344     case bfd_mach_mips4100:
2345       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
2346       break;
2347
2348     case bfd_mach_mips4111:
2349       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
2350       break;
2351
2352     case bfd_mach_mips4650:
2353       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
2354       break;
2355
2356     case bfd_mach_mips8000:
2357       val = E_MIPS_ARCH_4;
2358       break;
2359
2360     case bfd_mach_mips32:
2361       val = E_MIPS_ARCH_32;
2362       break;
2363
2364     case bfd_mach_mips32_4k:
2365       val = E_MIPS_ARCH_32 | E_MIPS_MACH_MIPS32_4K;
2366       break;
2367
2368     case bfd_mach_mips5:
2369       val = E_MIPS_ARCH_5;
2370       break;
2371
2372     case bfd_mach_mips64:
2373       val = E_MIPS_ARCH_64;
2374       break;
2375
2376     case bfd_mach_mips_sb1:
2377       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
2378       break;
2379     }
2380
2381   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
2382   elf_elfheader (abfd)->e_flags |= val;
2383
2384   /* Set the sh_info field for .gptab sections and other appropriate
2385      info for each special section.  */
2386   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
2387        i < elf_elfheader (abfd)->e_shnum;
2388        i++, hdrpp++)
2389     {
2390       switch ((*hdrpp)->sh_type)
2391         {
2392         case SHT_MIPS_MSYM:
2393         case SHT_MIPS_LIBLIST:
2394           sec = bfd_get_section_by_name (abfd, ".dynstr");
2395           if (sec != NULL)
2396             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2397           break;
2398
2399         case SHT_MIPS_GPTAB:
2400           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2401           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2402           BFD_ASSERT (name != NULL
2403                       && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
2404           sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
2405           BFD_ASSERT (sec != NULL);
2406           (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
2407           break;
2408
2409         case SHT_MIPS_CONTENT:
2410           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2411           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2412           BFD_ASSERT (name != NULL
2413                       && strncmp (name, ".MIPS.content",
2414                                   sizeof ".MIPS.content" - 1) == 0);
2415           sec = bfd_get_section_by_name (abfd,
2416                                          name + sizeof ".MIPS.content" - 1);
2417           BFD_ASSERT (sec != NULL);
2418           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2419           break;
2420
2421         case SHT_MIPS_SYMBOL_LIB:
2422           sec = bfd_get_section_by_name (abfd, ".dynsym");
2423           if (sec != NULL)
2424             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2425           sec = bfd_get_section_by_name (abfd, ".liblist");
2426           if (sec != NULL)
2427             (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
2428           break;
2429
2430         case SHT_MIPS_EVENTS:
2431           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2432           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2433           BFD_ASSERT (name != NULL);
2434           if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
2435             sec = bfd_get_section_by_name (abfd,
2436                                            name + sizeof ".MIPS.events" - 1);
2437           else
2438             {
2439               BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
2440                                    sizeof ".MIPS.post_rel" - 1) == 0);
2441               sec = bfd_get_section_by_name (abfd,
2442                                              (name
2443                                               + sizeof ".MIPS.post_rel" - 1));
2444             }
2445           BFD_ASSERT (sec != NULL);
2446           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2447           break;
2448
2449         }
2450     }
2451 }
2452 \f
2453 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
2454
2455 boolean
2456 _bfd_mips_elf_set_private_flags (abfd, flags)
2457      bfd *abfd;
2458      flagword flags;
2459 {
2460   BFD_ASSERT (!elf_flags_init (abfd)
2461               || elf_elfheader (abfd)->e_flags == flags);
2462
2463   elf_elfheader (abfd)->e_flags = flags;
2464   elf_flags_init (abfd) = true;
2465   return true;
2466 }
2467
2468 /* Copy backend specific data from one object module to another */
2469
2470 boolean
2471 _bfd_mips_elf_copy_private_bfd_data (ibfd, obfd)
2472      bfd *ibfd;
2473      bfd *obfd;
2474 {
2475   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2476       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2477     return true;
2478
2479   BFD_ASSERT (!elf_flags_init (obfd)
2480               || (elf_elfheader (obfd)->e_flags
2481                   == elf_elfheader (ibfd)->e_flags));
2482
2483   elf_gp (obfd) = elf_gp (ibfd);
2484   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2485   elf_flags_init (obfd) = true;
2486   return true;
2487 }
2488
2489 /* Merge backend specific data from an object file to the output
2490    object file when linking.  */
2491
2492 boolean
2493 _bfd_mips_elf_merge_private_bfd_data (ibfd, obfd)
2494      bfd *ibfd;
2495      bfd *obfd;
2496 {
2497   flagword old_flags;
2498   flagword new_flags;
2499   boolean ok;
2500   boolean null_input_bfd = true;
2501   asection *sec;
2502
2503   /* Check if we have the same endianess */
2504   if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2505     return false;
2506
2507   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2508       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2509     return true;
2510
2511   new_flags = elf_elfheader (ibfd)->e_flags;
2512   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
2513   old_flags = elf_elfheader (obfd)->e_flags;
2514
2515   if (! elf_flags_init (obfd))
2516     {
2517       elf_flags_init (obfd) = true;
2518       elf_elfheader (obfd)->e_flags = new_flags;
2519       elf_elfheader (obfd)->e_ident[EI_CLASS]
2520         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
2521
2522       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2523           && bfd_get_arch_info (obfd)->the_default)
2524         {
2525           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2526                                    bfd_get_mach (ibfd)))
2527             return false;
2528         }
2529
2530       return true;
2531     }
2532
2533   /* Check flag compatibility.  */
2534
2535   new_flags &= ~EF_MIPS_NOREORDER;
2536   old_flags &= ~EF_MIPS_NOREORDER;
2537
2538   if (new_flags == old_flags)
2539     return true;
2540
2541   /* Check to see if the input BFD actually contains any sections.
2542      If not, its flags may not have been initialised either, but it cannot
2543      actually cause any incompatibility.  */
2544   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2545     {
2546       /* Ignore synthetic sections and empty .text, .data and .bss sections
2547           which are automatically generated by gas.  */
2548       if (strcmp (sec->name, ".reginfo")
2549           && strcmp (sec->name, ".mdebug")
2550           && ((!strcmp (sec->name, ".text")
2551                || !strcmp (sec->name, ".data")
2552                || !strcmp (sec->name, ".bss"))
2553               && sec->_raw_size != 0))
2554         {
2555           null_input_bfd = false;
2556           break;
2557         }
2558     }
2559   if (null_input_bfd)
2560     return true;
2561
2562   ok = true;
2563
2564   if ((new_flags & EF_MIPS_PIC) != (old_flags & EF_MIPS_PIC))
2565     {
2566       new_flags &= ~EF_MIPS_PIC;
2567       old_flags &= ~EF_MIPS_PIC;
2568       (*_bfd_error_handler)
2569         (_("%s: linking PIC files with non-PIC files"),
2570          bfd_get_filename (ibfd));
2571       ok = false;
2572     }
2573
2574   if ((new_flags & EF_MIPS_CPIC) != (old_flags & EF_MIPS_CPIC))
2575     {
2576       new_flags &= ~EF_MIPS_CPIC;
2577       old_flags &= ~EF_MIPS_CPIC;
2578       (*_bfd_error_handler)
2579         (_("%s: linking abicalls files with non-abicalls files"),
2580          bfd_get_filename (ibfd));
2581       ok = false;
2582     }
2583
2584   /* Compare the ISA's.  */
2585   if ((new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH))
2586       != (old_flags & (EF_MIPS_ARCH | EF_MIPS_MACH)))
2587     {
2588       int new_mach = new_flags & EF_MIPS_MACH;
2589       int old_mach = old_flags & EF_MIPS_MACH;
2590       int new_isa = elf_mips_isa (new_flags);
2591       int old_isa = elf_mips_isa (old_flags);
2592
2593       /* If either has no machine specified, just compare the general isa's.
2594          Some combinations of machines are ok, if the isa's match.  */
2595       if (! new_mach
2596           || ! old_mach
2597           || new_mach == old_mach
2598           )
2599         {
2600           /* Don't warn about mixing code using 32-bit ISAs, or mixing code
2601              using 64-bit ISAs.  They will normally use the same data sizes
2602              and calling conventions.  */
2603
2604           if ((  (new_isa == 1 || new_isa == 2 || new_isa == 32)
2605                ^ (old_isa == 1 || old_isa == 2 || old_isa == 32)) != 0)
2606             {
2607               (*_bfd_error_handler)
2608                (_("%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"),
2609                 bfd_get_filename (ibfd), new_isa, old_isa);
2610               ok = false;
2611             }
2612         }
2613
2614       else
2615         {
2616           (*_bfd_error_handler)
2617             (_("%s: ISA mismatch (%d) with previous modules (%d)"),
2618              bfd_get_filename (ibfd),
2619              elf_mips_mach (new_flags),
2620              elf_mips_mach (old_flags));
2621           ok = false;
2622         }
2623
2624       new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
2625       old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
2626     }
2627
2628   /* Compare ABI's.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
2629      does set EI_CLASS differently from any 32-bit ABI.  */
2630   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
2631       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
2632           != elf_elfheader (obfd)->e_ident[EI_CLASS]))
2633     {
2634       /* Only error if both are set (to different values).  */
2635       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
2636           || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
2637               != elf_elfheader (obfd)->e_ident[EI_CLASS]))
2638         {
2639           (*_bfd_error_handler)
2640             (_("%s: ABI mismatch: linking %s module with previous %s modules"),
2641              bfd_get_filename (ibfd),
2642              elf_mips_abi_name (ibfd),
2643              elf_mips_abi_name (obfd));
2644           ok = false;
2645         }
2646       new_flags &= ~EF_MIPS_ABI;
2647       old_flags &= ~EF_MIPS_ABI;
2648     }
2649
2650   /* Warn about any other mismatches */
2651   if (new_flags != old_flags)
2652     {
2653       (*_bfd_error_handler)
2654         (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2655          bfd_get_filename (ibfd), (unsigned long) new_flags,
2656          (unsigned long) old_flags);
2657       ok = false;
2658     }
2659
2660   if (! ok)
2661     {
2662       bfd_set_error (bfd_error_bad_value);
2663       return false;
2664     }
2665
2666   return true;
2667 }
2668 \f
2669 boolean
2670 _bfd_mips_elf_print_private_bfd_data (abfd, ptr)
2671      bfd *abfd;
2672      PTR ptr;
2673 {
2674   FILE *file = (FILE *) ptr;
2675
2676   BFD_ASSERT (abfd != NULL && ptr != NULL);
2677
2678   /* Print normal ELF private data.  */
2679   _bfd_elf_print_private_bfd_data (abfd, ptr);
2680
2681   /* xgettext:c-format */
2682   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2683
2684   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
2685     fprintf (file, _(" [abi=O32]"));
2686   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
2687     fprintf (file, _(" [abi=O64]"));
2688   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
2689     fprintf (file, _(" [abi=EABI32]"));
2690   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
2691     fprintf (file, _(" [abi=EABI64]"));
2692   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
2693     fprintf (file, _(" [abi unknown]"));
2694   else if (ABI_N32_P (abfd))
2695     fprintf (file, _(" [abi=N32]"));
2696   else if (ABI_64_P (abfd))
2697     fprintf (file, _(" [abi=64]"));
2698   else
2699     fprintf (file, _(" [no abi set]"));
2700
2701   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
2702     fprintf (file, _(" [mips1]"));
2703   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
2704     fprintf (file, _(" [mips2]"));
2705   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
2706     fprintf (file, _(" [mips3]"));
2707   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
2708     fprintf (file, _(" [mips4]"));
2709   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
2710     fprintf (file, _ (" [mips5]"));
2711   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
2712     fprintf (file, _ (" [mips32]"));
2713   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
2714     fprintf (file, _ (" [mips64]"));
2715   else
2716     fprintf (file, _(" [unknown ISA]"));
2717
2718   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
2719     fprintf (file, _(" [32bitmode]"));
2720   else
2721     fprintf (file, _(" [not 32bitmode]"));
2722
2723   fputc ('\n', file);
2724
2725   return true;
2726 }
2727 \f
2728 /* Handle a MIPS specific section when reading an object file.  This
2729    is called when elfcode.h finds a section with an unknown type.
2730    This routine supports both the 32-bit and 64-bit ELF ABI.
2731
2732    FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2733    how to.  */
2734
2735 boolean
2736 _bfd_mips_elf_section_from_shdr (abfd, hdr, name)
2737      bfd *abfd;
2738      Elf_Internal_Shdr *hdr;
2739      char *name;
2740 {
2741   flagword flags = 0;
2742
2743   /* There ought to be a place to keep ELF backend specific flags, but
2744      at the moment there isn't one.  We just keep track of the
2745      sections by their name, instead.  Fortunately, the ABI gives
2746      suggested names for all the MIPS specific sections, so we will
2747      probably get away with this.  */
2748   switch (hdr->sh_type)
2749     {
2750     case SHT_MIPS_LIBLIST:
2751       if (strcmp (name, ".liblist") != 0)
2752         return false;
2753       break;
2754     case SHT_MIPS_MSYM:
2755       if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (abfd)) != 0)
2756         return false;
2757       break;
2758     case SHT_MIPS_CONFLICT:
2759       if (strcmp (name, ".conflict") != 0)
2760         return false;
2761       break;
2762     case SHT_MIPS_GPTAB:
2763       if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
2764         return false;
2765       break;
2766     case SHT_MIPS_UCODE:
2767       if (strcmp (name, ".ucode") != 0)
2768         return false;
2769       break;
2770     case SHT_MIPS_DEBUG:
2771       if (strcmp (name, ".mdebug") != 0)
2772         return false;
2773       flags = SEC_DEBUGGING;
2774       break;
2775     case SHT_MIPS_REGINFO:
2776       if (strcmp (name, ".reginfo") != 0
2777           || hdr->sh_size != sizeof (Elf32_External_RegInfo))
2778         return false;
2779       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
2780       break;
2781     case SHT_MIPS_IFACE:
2782       if (strcmp (name, ".MIPS.interfaces") != 0)
2783         return false;
2784       break;
2785     case SHT_MIPS_CONTENT:
2786       if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
2787         return false;
2788       break;
2789     case SHT_MIPS_OPTIONS:
2790       if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) != 0)
2791         return false;
2792       break;
2793     case SHT_MIPS_DWARF:
2794       if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0)
2795         return false;
2796       break;
2797     case SHT_MIPS_SYMBOL_LIB:
2798       if (strcmp (name, ".MIPS.symlib") != 0)
2799         return false;
2800       break;
2801     case SHT_MIPS_EVENTS:
2802       if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
2803           && strncmp (name, ".MIPS.post_rel",
2804                       sizeof ".MIPS.post_rel" - 1) != 0)
2805         return false;
2806       break;
2807     default:
2808       return false;
2809     }
2810
2811   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2812     return false;
2813
2814   if (flags)
2815     {
2816       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2817                                    (bfd_get_section_flags (abfd,
2818                                                            hdr->bfd_section)
2819                                     | flags)))
2820         return false;
2821     }
2822
2823   /* FIXME: We should record sh_info for a .gptab section.  */
2824
2825   /* For a .reginfo section, set the gp value in the tdata information
2826      from the contents of this section.  We need the gp value while
2827      processing relocs, so we just get it now.  The .reginfo section
2828      is not used in the 64-bit MIPS ELF ABI.  */
2829   if (hdr->sh_type == SHT_MIPS_REGINFO)
2830     {
2831       Elf32_External_RegInfo ext;
2832       Elf32_RegInfo s;
2833
2834       if (! bfd_get_section_contents (abfd, hdr->bfd_section, (PTR) &ext,
2835                                       (file_ptr) 0, sizeof ext))
2836         return false;
2837       bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
2838       elf_gp (abfd) = s.ri_gp_value;
2839     }
2840
2841   /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2842      set the gp value based on what we find.  We may see both
2843      SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2844      they should agree.  */
2845   if (hdr->sh_type == SHT_MIPS_OPTIONS)
2846     {
2847       bfd_byte *contents, *l, *lend;
2848
2849       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
2850       if (contents == NULL)
2851         return false;
2852       if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
2853                                       (file_ptr) 0, hdr->sh_size))
2854         {
2855           free (contents);
2856           return false;
2857         }
2858       l = contents;
2859       lend = contents + hdr->sh_size;
2860       while (l + sizeof (Elf_External_Options) <= lend)
2861         {
2862           Elf_Internal_Options intopt;
2863
2864           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
2865                                         &intopt);
2866           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
2867             {
2868               Elf64_Internal_RegInfo intreg;
2869
2870               bfd_mips_elf64_swap_reginfo_in
2871                 (abfd,
2872                  ((Elf64_External_RegInfo *)
2873                   (l + sizeof (Elf_External_Options))),
2874                  &intreg);
2875               elf_gp (abfd) = intreg.ri_gp_value;
2876             }
2877           else if (intopt.kind == ODK_REGINFO)
2878             {
2879               Elf32_RegInfo intreg;
2880
2881               bfd_mips_elf32_swap_reginfo_in
2882                 (abfd,
2883                  ((Elf32_External_RegInfo *)
2884                   (l + sizeof (Elf_External_Options))),
2885                  &intreg);
2886               elf_gp (abfd) = intreg.ri_gp_value;
2887             }
2888           l += intopt.size;
2889         }
2890       free (contents);
2891     }
2892
2893   return true;
2894 }
2895
2896 /* Set the correct type for a MIPS ELF section.  We do this by the
2897    section name, which is a hack, but ought to work.  This routine is
2898    used by both the 32-bit and the 64-bit ABI.  */
2899
2900 boolean
2901 _bfd_mips_elf_fake_sections (abfd, hdr, sec)
2902      bfd *abfd;
2903      Elf32_Internal_Shdr *hdr;
2904      asection *sec;
2905 {
2906   register const char *name;
2907
2908   name = bfd_get_section_name (abfd, sec);
2909
2910   if (strcmp (name, ".liblist") == 0)
2911     {
2912       hdr->sh_type = SHT_MIPS_LIBLIST;
2913       hdr->sh_info = sec->_raw_size / sizeof (Elf32_Lib);
2914       /* The sh_link field is set in final_write_processing.  */
2915     }
2916   else if (strcmp (name, ".conflict") == 0)
2917     hdr->sh_type = SHT_MIPS_CONFLICT;
2918   else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
2919     {
2920       hdr->sh_type = SHT_MIPS_GPTAB;
2921       hdr->sh_entsize = sizeof (Elf32_External_gptab);
2922       /* The sh_info field is set in final_write_processing.  */
2923     }
2924   else if (strcmp (name, ".ucode") == 0)
2925     hdr->sh_type = SHT_MIPS_UCODE;
2926   else if (strcmp (name, ".mdebug") == 0)
2927     {
2928       hdr->sh_type = SHT_MIPS_DEBUG;
2929       /* In a shared object on Irix 5.3, the .mdebug section has an
2930          entsize of 0.  FIXME: Does this matter?  */
2931       if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
2932         hdr->sh_entsize = 0;
2933       else
2934         hdr->sh_entsize = 1;
2935     }
2936   else if (strcmp (name, ".reginfo") == 0)
2937     {
2938       hdr->sh_type = SHT_MIPS_REGINFO;
2939       /* In a shared object on Irix 5.3, the .reginfo section has an
2940          entsize of 0x18.  FIXME: Does this matter?  */
2941       if (SGI_COMPAT (abfd))
2942         {
2943           if ((abfd->flags & DYNAMIC) != 0)
2944             hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
2945           else
2946             hdr->sh_entsize = 1;
2947         }
2948       else
2949         hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
2950     }
2951   else if (SGI_COMPAT (abfd)
2952            && (strcmp (name, ".hash") == 0
2953                || strcmp (name, ".dynamic") == 0
2954                || strcmp (name, ".dynstr") == 0))
2955     {
2956       if (SGI_COMPAT (abfd))
2957         hdr->sh_entsize = 0;
2958 #if 0
2959       /* This isn't how the Irix 6 linker behaves.  */
2960       hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
2961 #endif
2962     }
2963   else if (strcmp (name, ".got") == 0
2964            || strcmp (name, MIPS_ELF_SRDATA_SECTION_NAME (abfd)) == 0
2965            || strcmp (name, ".sdata") == 0
2966            || strcmp (name, ".sbss") == 0
2967            || strcmp (name, ".lit4") == 0
2968            || strcmp (name, ".lit8") == 0)
2969     hdr->sh_flags |= SHF_MIPS_GPREL;
2970   else if (strcmp (name, ".MIPS.interfaces") == 0)
2971     {
2972       hdr->sh_type = SHT_MIPS_IFACE;
2973       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
2974     }
2975   else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0)
2976     {
2977       hdr->sh_type = SHT_MIPS_CONTENT;
2978       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
2979       /* The sh_info field is set in final_write_processing.  */
2980     }
2981   else if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
2982     {
2983       hdr->sh_type = SHT_MIPS_OPTIONS;
2984       hdr->sh_entsize = 1;
2985       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
2986     }
2987   else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0)
2988     hdr->sh_type = SHT_MIPS_DWARF;
2989   else if (strcmp (name, ".MIPS.symlib") == 0)
2990     {
2991       hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
2992       /* The sh_link and sh_info fields are set in
2993          final_write_processing.  */
2994     }
2995   else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
2996            || strncmp (name, ".MIPS.post_rel",
2997                        sizeof ".MIPS.post_rel" - 1) == 0)
2998     {
2999       hdr->sh_type = SHT_MIPS_EVENTS;
3000       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
3001       /* The sh_link field is set in final_write_processing.  */
3002     }
3003   else if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (abfd)) == 0)
3004     {
3005       hdr->sh_type = SHT_MIPS_MSYM;
3006       hdr->sh_flags |= SHF_ALLOC;
3007       hdr->sh_entsize = 8;
3008     }
3009
3010   /* The generic elf_fake_sections will set up REL_HDR using the
3011      default kind of relocations.  But, we may actually need both
3012      kinds of relocations, so we set up the second header here.  */
3013   if ((sec->flags & SEC_RELOC) != 0)
3014     {
3015       struct bfd_elf_section_data *esd;
3016
3017       esd = elf_section_data (sec);
3018       BFD_ASSERT (esd->rel_hdr2 == NULL);
3019       esd->rel_hdr2
3020         = (Elf_Internal_Shdr *) bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
3021       if (!esd->rel_hdr2)
3022         return false;
3023       _bfd_elf_init_reloc_shdr (abfd, esd->rel_hdr2, sec,
3024                                 !elf_section_data (sec)->use_rela_p);
3025     }
3026
3027   return true;
3028 }
3029
3030 /* Given a BFD section, try to locate the corresponding ELF section
3031    index.  This is used by both the 32-bit and the 64-bit ABI.
3032    Actually, it's not clear to me that the 64-bit ABI supports these,
3033    but for non-PIC objects we will certainly want support for at least
3034    the .scommon section.  */
3035
3036 boolean
3037 _bfd_mips_elf_section_from_bfd_section (abfd, hdr, sec, retval)
3038      bfd *abfd ATTRIBUTE_UNUSED;
3039      Elf32_Internal_Shdr *hdr ATTRIBUTE_UNUSED;
3040      asection *sec;
3041      int *retval;
3042 {
3043   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
3044     {
3045       *retval = SHN_MIPS_SCOMMON;
3046       return true;
3047     }
3048   if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
3049     {
3050       *retval = SHN_MIPS_ACOMMON;
3051       return true;
3052     }
3053   return false;
3054 }
3055
3056 /* When are writing out the .options or .MIPS.options section,
3057    remember the bytes we are writing out, so that we can install the
3058    GP value in the section_processing routine.  */
3059
3060 boolean
3061 _bfd_mips_elf_set_section_contents (abfd, section, location, offset, count)
3062      bfd *abfd;
3063      sec_ptr section;
3064      PTR location;
3065      file_ptr offset;
3066      bfd_size_type count;
3067 {
3068   if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
3069     {
3070       bfd_byte *c;
3071
3072       if (elf_section_data (section) == NULL)
3073         {
3074           section->used_by_bfd =
3075             (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
3076           if (elf_section_data (section) == NULL)
3077             return false;
3078         }
3079       c = (bfd_byte *) elf_section_data (section)->tdata;
3080       if (c == NULL)
3081         {
3082           bfd_size_type size;
3083
3084           if (section->_cooked_size != 0)
3085             size = section->_cooked_size;
3086           else
3087             size = section->_raw_size;
3088           c = (bfd_byte *) bfd_zalloc (abfd, size);
3089           if (c == NULL)
3090             return false;
3091           elf_section_data (section)->tdata = (PTR) c;
3092         }
3093
3094       memcpy (c + offset, location, count);
3095     }
3096
3097   return _bfd_elf_set_section_contents (abfd, section, location, offset,
3098                                         count);
3099 }
3100
3101 /* Work over a section just before writing it out.  This routine is
3102    used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
3103    sections that need the SHF_MIPS_GPREL flag by name; there has to be
3104    a better way.  */
3105
3106 boolean
3107 _bfd_mips_elf_section_processing (abfd, hdr)
3108      bfd *abfd;
3109      Elf_Internal_Shdr *hdr;
3110 {
3111   if (hdr->sh_type == SHT_MIPS_REGINFO
3112       && hdr->sh_size > 0)
3113     {
3114       bfd_byte buf[4];
3115
3116       BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
3117       BFD_ASSERT (hdr->contents == NULL);
3118
3119       if (bfd_seek (abfd,
3120                     hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
3121                     SEEK_SET) == -1)
3122         return false;
3123       bfd_h_put_32 (abfd, (bfd_vma) elf_gp (abfd), buf);
3124       if (bfd_write (buf, (bfd_size_type) 1, (bfd_size_type) 4, abfd) != 4)
3125         return false;
3126     }
3127
3128   if (hdr->sh_type == SHT_MIPS_OPTIONS
3129       && hdr->bfd_section != NULL
3130       && elf_section_data (hdr->bfd_section) != NULL
3131       && elf_section_data (hdr->bfd_section)->tdata != NULL)
3132     {
3133       bfd_byte *contents, *l, *lend;
3134
3135       /* We stored the section contents in the elf_section_data tdata
3136          field in the set_section_contents routine.  We save the
3137          section contents so that we don't have to read them again.
3138          At this point we know that elf_gp is set, so we can look
3139          through the section contents to see if there is an
3140          ODK_REGINFO structure.  */
3141
3142       contents = (bfd_byte *) elf_section_data (hdr->bfd_section)->tdata;
3143       l = contents;
3144       lend = contents + hdr->sh_size;
3145       while (l + sizeof (Elf_External_Options) <= lend)
3146         {
3147           Elf_Internal_Options intopt;
3148
3149           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
3150                                         &intopt);
3151           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
3152             {
3153               bfd_byte buf[8];
3154
3155               if (bfd_seek (abfd,
3156                             (hdr->sh_offset
3157                              + (l - contents)
3158                              + sizeof (Elf_External_Options)
3159                              + (sizeof (Elf64_External_RegInfo) - 8)),
3160                              SEEK_SET) == -1)
3161                 return false;
3162               bfd_h_put_64 (abfd, elf_gp (abfd), buf);
3163               if (bfd_write (buf, 1, 8, abfd) != 8)
3164                 return false;
3165             }
3166           else if (intopt.kind == ODK_REGINFO)
3167             {
3168               bfd_byte buf[4];
3169
3170               if (bfd_seek (abfd,
3171                             (hdr->sh_offset
3172                              + (l - contents)
3173                              + sizeof (Elf_External_Options)
3174                              + (sizeof (Elf32_External_RegInfo) - 4)),
3175                             SEEK_SET) == -1)
3176                 return false;
3177               bfd_h_put_32 (abfd, elf_gp (abfd), buf);
3178               if (bfd_write (buf, 1, 4, abfd) != 4)
3179                 return false;
3180             }
3181           l += intopt.size;
3182         }
3183     }
3184
3185   if (hdr->bfd_section != NULL)
3186     {
3187       const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
3188
3189       if (strcmp (name, ".sdata") == 0
3190           || strcmp (name, ".lit8") == 0
3191           || strcmp (name, ".lit4") == 0)
3192         {
3193           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
3194           hdr->sh_type = SHT_PROGBITS;
3195         }
3196       else if (strcmp (name, ".sbss") == 0)
3197         {
3198           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
3199           hdr->sh_type = SHT_NOBITS;
3200         }
3201       else if (strcmp (name, MIPS_ELF_SRDATA_SECTION_NAME (abfd)) == 0)
3202         {
3203           hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
3204           hdr->sh_type = SHT_PROGBITS;
3205         }
3206       else if (strcmp (name, ".compact_rel") == 0)
3207         {
3208           hdr->sh_flags = 0;
3209           hdr->sh_type = SHT_PROGBITS;
3210         }
3211       else if (strcmp (name, ".rtproc") == 0)
3212         {
3213           if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
3214             {
3215               unsigned int adjust;
3216
3217               adjust = hdr->sh_size % hdr->sh_addralign;
3218               if (adjust != 0)
3219                 hdr->sh_size += hdr->sh_addralign - adjust;
3220             }
3221         }
3222     }
3223
3224   return true;
3225 }
3226 \f
3227 /* MIPS ELF uses two common sections.  One is the usual one, and the
3228    other is for small objects.  All the small objects are kept
3229    together, and then referenced via the gp pointer, which yields
3230    faster assembler code.  This is what we use for the small common
3231    section.  This approach is copied from ecoff.c.  */
3232 static asection mips_elf_scom_section;
3233 static asymbol mips_elf_scom_symbol;
3234 static asymbol *mips_elf_scom_symbol_ptr;
3235
3236 /* MIPS ELF also uses an acommon section, which represents an
3237    allocated common symbol which may be overridden by a
3238    definition in a shared library.  */
3239 static asection mips_elf_acom_section;
3240 static asymbol mips_elf_acom_symbol;
3241 static asymbol *mips_elf_acom_symbol_ptr;
3242
3243 /* Handle the special MIPS section numbers that a symbol may use.
3244    This is used for both the 32-bit and the 64-bit ABI.  */
3245
3246 void
3247 _bfd_mips_elf_symbol_processing (abfd, asym)
3248      bfd *abfd;
3249      asymbol *asym;
3250 {
3251   elf_symbol_type *elfsym;
3252
3253   elfsym = (elf_symbol_type *) asym;
3254   switch (elfsym->internal_elf_sym.st_shndx)
3255     {
3256     case SHN_MIPS_ACOMMON:
3257       /* This section is used in a dynamically linked executable file.
3258          It is an allocated common section.  The dynamic linker can
3259          either resolve these symbols to something in a shared
3260          library, or it can just leave them here.  For our purposes,
3261          we can consider these symbols to be in a new section.  */
3262       if (mips_elf_acom_section.name == NULL)
3263         {
3264           /* Initialize the acommon section.  */
3265           mips_elf_acom_section.name = ".acommon";
3266           mips_elf_acom_section.flags = SEC_ALLOC;
3267           mips_elf_acom_section.output_section = &mips_elf_acom_section;
3268           mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
3269           mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
3270           mips_elf_acom_symbol.name = ".acommon";
3271           mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
3272           mips_elf_acom_symbol.section = &mips_elf_acom_section;
3273           mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
3274         }
3275       asym->section = &mips_elf_acom_section;
3276       break;
3277
3278     case SHN_COMMON:
3279       /* Common symbols less than the GP size are automatically
3280          treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
3281       if (asym->value > elf_gp_size (abfd)
3282           || IRIX_COMPAT (abfd) == ict_irix6)
3283         break;
3284       /* Fall through.  */
3285     case SHN_MIPS_SCOMMON:
3286       if (mips_elf_scom_section.name == NULL)
3287         {
3288           /* Initialize the small common section.  */
3289           mips_elf_scom_section.name = ".scommon";
3290           mips_elf_scom_section.flags = SEC_IS_COMMON;
3291           mips_elf_scom_section.output_section = &mips_elf_scom_section;
3292           mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
3293           mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
3294           mips_elf_scom_symbol.name = ".scommon";
3295           mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
3296           mips_elf_scom_symbol.section = &mips_elf_scom_section;
3297           mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
3298         }
3299       asym->section = &mips_elf_scom_section;
3300       asym->value = elfsym->internal_elf_sym.st_size;
3301       break;
3302
3303     case SHN_MIPS_SUNDEFINED:
3304       asym->section = bfd_und_section_ptr;
3305       break;
3306
3307 #if 0 /* for SGI_COMPAT */
3308     case SHN_MIPS_TEXT:
3309       asym->section = mips_elf_text_section_ptr;
3310       break;
3311
3312     case SHN_MIPS_DATA:
3313       asym->section = mips_elf_data_section_ptr;
3314       break;
3315 #endif
3316     }
3317 }
3318 \f
3319 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
3320    segments.  */
3321
3322 int
3323 _bfd_mips_elf_additional_program_headers (abfd)
3324      bfd *abfd;
3325 {
3326   asection *s;
3327   int ret = 0;
3328
3329   /* See if we need a PT_MIPS_REGINFO segment.  */
3330   s = bfd_get_section_by_name (abfd, ".reginfo");
3331   if (s && (s->flags & SEC_LOAD))
3332     ++ret;
3333
3334   /* See if we need a PT_MIPS_OPTIONS segment.  */
3335   if (IRIX_COMPAT (abfd) == ict_irix6
3336       && bfd_get_section_by_name (abfd,
3337                                   MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
3338     ++ret;
3339
3340   /* See if we need a PT_MIPS_RTPROC segment.  */
3341   if (IRIX_COMPAT (abfd) == ict_irix5
3342       && bfd_get_section_by_name (abfd, ".dynamic")
3343       && bfd_get_section_by_name (abfd, ".mdebug"))
3344     ++ret;
3345
3346   return ret;
3347 }
3348
3349 /* Modify the segment map for an Irix 5 executable.  */
3350
3351 boolean
3352 _bfd_mips_elf_modify_segment_map (abfd)
3353      bfd *abfd;
3354 {
3355   asection *s;
3356   struct elf_segment_map *m, **pm;
3357
3358   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
3359      segment.  */
3360   s = bfd_get_section_by_name (abfd, ".reginfo");
3361   if (s != NULL && (s->flags & SEC_LOAD) != 0)
3362     {
3363       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3364         if (m->p_type == PT_MIPS_REGINFO)
3365           break;
3366       if (m == NULL)
3367         {
3368           m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
3369           if (m == NULL)
3370             return false;
3371
3372           m->p_type = PT_MIPS_REGINFO;
3373           m->count = 1;
3374           m->sections[0] = s;
3375
3376           /* We want to put it after the PHDR and INTERP segments.  */
3377           pm = &elf_tdata (abfd)->segment_map;
3378           while (*pm != NULL
3379                  && ((*pm)->p_type == PT_PHDR
3380                      || (*pm)->p_type == PT_INTERP))
3381             pm = &(*pm)->next;
3382
3383           m->next = *pm;
3384           *pm = m;
3385         }
3386     }
3387
3388   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
3389      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
3390      PT_OPTIONS segement immediately following the program header
3391      table.  */
3392   if (IRIX_COMPAT (abfd) == ict_irix6)
3393     {
3394       asection *s;
3395
3396       for (s = abfd->sections; s; s = s->next)
3397         if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
3398           break;
3399
3400       if (s)
3401         {
3402           struct elf_segment_map *options_segment;
3403
3404           /* Usually, there's a program header table.  But, sometimes
3405              there's not (like when running the `ld' testsuite).  So,
3406              if there's no program header table, we just put the
3407              options segement at the end.  */
3408           for (pm = &elf_tdata (abfd)->segment_map;
3409                *pm != NULL;
3410                pm = &(*pm)->next)
3411             if ((*pm)->p_type == PT_PHDR)
3412               break;
3413
3414           options_segment = bfd_zalloc (abfd,
3415                                         sizeof (struct elf_segment_map));
3416           options_segment->next = *pm;
3417           options_segment->p_type = PT_MIPS_OPTIONS;
3418           options_segment->p_flags = PF_R;
3419           options_segment->p_flags_valid = true;
3420           options_segment->count = 1;
3421           options_segment->sections[0] = s;
3422           *pm = options_segment;
3423         }
3424     }
3425   else
3426     {
3427       if (IRIX_COMPAT (abfd) == ict_irix5)
3428         {
3429           /* If there are .dynamic and .mdebug sections, we make a room
3430              for the RTPROC header.  FIXME: Rewrite without section names.  */
3431           if (bfd_get_section_by_name (abfd, ".interp") == NULL
3432               && bfd_get_section_by_name (abfd, ".dynamic") != NULL
3433               && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
3434             {
3435               for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3436                 if (m->p_type == PT_MIPS_RTPROC)
3437                   break;
3438               if (m == NULL)
3439                 {
3440                   m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
3441                   if (m == NULL)
3442                     return false;
3443
3444                   m->p_type = PT_MIPS_RTPROC;
3445
3446                   s = bfd_get_section_by_name (abfd, ".rtproc");
3447                   if (s == NULL)
3448                     {
3449                       m->count = 0;
3450                       m->p_flags = 0;
3451                       m->p_flags_valid = 1;
3452                     }
3453                   else
3454                     {
3455                       m->count = 1;
3456                       m->sections[0] = s;
3457                     }
3458
3459                   /* We want to put it after the DYNAMIC segment.  */
3460                   pm = &elf_tdata (abfd)->segment_map;
3461                   while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
3462                     pm = &(*pm)->next;
3463                   if (*pm != NULL)
3464                     pm = &(*pm)->next;
3465
3466                   m->next = *pm;
3467                   *pm = m;
3468                 }
3469             }
3470         }
3471       /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic,
3472          .dynstr, .dynsym, and .hash sections, and everything in
3473          between.  */
3474       for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
3475            pm = &(*pm)->next)
3476         if ((*pm)->p_type == PT_DYNAMIC)
3477           break;
3478       m = *pm;
3479       if (IRIX_COMPAT (abfd) == ict_none)
3480         {
3481           /* For a normal mips executable the permissions for the PT_DYNAMIC
3482              segment are read, write and execute. We do that here since
3483              the code in elf.c sets only the read permission. This matters
3484              sometimes for the dynamic linker.  */
3485           if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3486             {
3487               m->p_flags = PF_R | PF_W | PF_X;
3488               m->p_flags_valid = 1;
3489             }
3490         }
3491       if (m != NULL
3492           && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
3493         {
3494           static const char *sec_names[] = {
3495             ".dynamic", ".dynstr", ".dynsym", ".hash"
3496           };
3497           bfd_vma low, high;
3498           unsigned int i, c;
3499           struct elf_segment_map *n;
3500
3501           low = 0xffffffff;
3502           high = 0;
3503           for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
3504             {
3505               s = bfd_get_section_by_name (abfd, sec_names[i]);
3506               if (s != NULL && (s->flags & SEC_LOAD) != 0)
3507                 {
3508                   bfd_size_type sz;
3509
3510                   if (low > s->vma)
3511                     low = s->vma;
3512                   sz = s->_cooked_size;
3513                   if (sz == 0)
3514                     sz = s->_raw_size;
3515                   if (high < s->vma + sz)
3516                     high = s->vma + sz;
3517                 }
3518             }
3519
3520           c = 0;
3521           for (s = abfd->sections; s != NULL; s = s->next)
3522             if ((s->flags & SEC_LOAD) != 0
3523                 && s->vma >= low
3524                 && ((s->vma
3525                      + (s->_cooked_size !=
3526                         0 ? s->_cooked_size : s->_raw_size)) <= high))
3527               ++c;
3528
3529           n = ((struct elf_segment_map *)
3530                bfd_zalloc (abfd, sizeof *n + (c - 1) * sizeof (asection *)));
3531           if (n == NULL)
3532             return false;
3533           *n = *m;
3534           n->count = c;
3535
3536           i = 0;
3537           for (s = abfd->sections; s != NULL; s = s->next)
3538             {
3539               if ((s->flags & SEC_LOAD) != 0
3540                   && s->vma >= low
3541                   && ((s->vma
3542                        + (s->_cooked_size != 0 ?
3543                           s->_cooked_size : s->_raw_size)) <= high))
3544                 {
3545                   n->sections[i] = s;
3546                   ++i;
3547                 }
3548             }
3549
3550           *pm = n;
3551         }
3552     }
3553
3554   return true;
3555 }
3556 \f
3557 /* The structure of the runtime procedure descriptor created by the
3558    loader for use by the static exception system.  */
3559
3560 typedef struct runtime_pdr {
3561         bfd_vma adr;            /* memory address of start of procedure */
3562         long    regmask;        /* save register mask */
3563         long    regoffset;      /* save register offset */
3564         long    fregmask;       /* save floating point register mask */
3565         long    fregoffset;     /* save floating point register offset */
3566         long    frameoffset;    /* frame size */
3567         short   framereg;       /* frame pointer register */
3568         short   pcreg;          /* offset or reg of return pc */
3569         long    irpss;          /* index into the runtime string table */
3570         long    reserved;
3571         struct exception_info *exception_info;/* pointer to exception array */
3572 } RPDR, *pRPDR;
3573 #define cbRPDR sizeof (RPDR)
3574 #define rpdNil ((pRPDR) 0)
3575
3576 /* Swap RPDR (runtime procedure table entry) for output.  */
3577
3578 static void ecoff_swap_rpdr_out
3579   PARAMS ((bfd *, const RPDR *, struct rpdr_ext *));
3580
3581 static void
3582 ecoff_swap_rpdr_out (abfd, in, ex)
3583      bfd *abfd;
3584      const RPDR *in;
3585      struct rpdr_ext *ex;
3586 {
3587   /* ecoff_put_off was defined in ecoffswap.h.  */
3588   ecoff_put_off (abfd, in->adr, (bfd_byte *) ex->p_adr);
3589   bfd_h_put_32 (abfd, in->regmask, (bfd_byte *) ex->p_regmask);
3590   bfd_h_put_32 (abfd, in->regoffset, (bfd_byte *) ex->p_regoffset);
3591   bfd_h_put_32 (abfd, in->fregmask, (bfd_byte *) ex->p_fregmask);
3592   bfd_h_put_32 (abfd, in->fregoffset, (bfd_byte *) ex->p_fregoffset);
3593   bfd_h_put_32 (abfd, in->frameoffset, (bfd_byte *) ex->p_frameoffset);
3594
3595   bfd_h_put_16 (abfd, in->framereg, (bfd_byte *) ex->p_framereg);
3596   bfd_h_put_16 (abfd, in->pcreg, (bfd_byte *) ex->p_pcreg);
3597
3598   bfd_h_put_32 (abfd, in->irpss, (bfd_byte *) ex->p_irpss);
3599 #if 0 /* FIXME */
3600   ecoff_put_off (abfd, in->exception_info, (bfd_byte *) ex->p_exception_info);
3601 #endif
3602 }
3603 \f
3604 /* Read ECOFF debugging information from a .mdebug section into a
3605    ecoff_debug_info structure.  */
3606
3607 boolean
3608 _bfd_mips_elf_read_ecoff_info (abfd, section, debug)
3609      bfd *abfd;
3610      asection *section;
3611      struct ecoff_debug_info *debug;
3612 {
3613   HDRR *symhdr;
3614   const struct ecoff_debug_swap *swap;
3615   char *ext_hdr = NULL;
3616
3617   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3618   memset (debug, 0, sizeof (*debug));
3619
3620   ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
3621   if (ext_hdr == NULL && swap->external_hdr_size != 0)
3622     goto error_return;
3623
3624   if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
3625                                 swap->external_hdr_size)
3626       == false)
3627     goto error_return;
3628
3629   symhdr = &debug->symbolic_header;
3630   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
3631
3632   /* The symbolic header contains absolute file offsets and sizes to
3633      read.  */
3634 #define READ(ptr, offset, count, size, type)                            \
3635   if (symhdr->count == 0)                                               \
3636     debug->ptr = NULL;                                                  \
3637   else                                                                  \
3638     {                                                                   \
3639       debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
3640       if (debug->ptr == NULL)                                           \
3641         goto error_return;                                              \
3642       if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0     \
3643           || (bfd_read (debug->ptr, size, symhdr->count,                \
3644                         abfd) != size * symhdr->count))                 \
3645         goto error_return;                                              \
3646     }
3647
3648   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
3649   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
3650   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
3651   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
3652   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
3653   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
3654         union aux_ext *);
3655   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
3656   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
3657   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
3658   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
3659   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
3660 #undef READ
3661
3662   debug->fdr = NULL;
3663   debug->adjust = NULL;
3664
3665   return true;
3666
3667  error_return:
3668   if (ext_hdr != NULL)
3669     free (ext_hdr);
3670   if (debug->line != NULL)
3671     free (debug->line);
3672   if (debug->external_dnr != NULL)
3673     free (debug->external_dnr);
3674   if (debug->external_pdr != NULL)
3675     free (debug->external_pdr);
3676   if (debug->external_sym != NULL)
3677     free (debug->external_sym);
3678   if (debug->external_opt != NULL)
3679     free (debug->external_opt);
3680   if (debug->external_aux != NULL)
3681     free (debug->external_aux);
3682   if (debug->ss != NULL)
3683     free (debug->ss);
3684   if (debug->ssext != NULL)
3685     free (debug->ssext);
3686   if (debug->external_fdr != NULL)
3687     free (debug->external_fdr);
3688   if (debug->external_rfd != NULL)
3689     free (debug->external_rfd);
3690   if (debug->external_ext != NULL)
3691     free (debug->external_ext);
3692   return false;
3693 }
3694 \f
3695 /* MIPS ELF local labels start with '$', not 'L'.  */
3696
3697 static boolean
3698 mips_elf_is_local_label_name (abfd, name)
3699      bfd *abfd;
3700      const char *name;
3701 {
3702   if (name[0] == '$')
3703     return true;
3704
3705   /* On Irix 6, the labels go back to starting with '.', so we accept
3706      the generic ELF local label syntax as well.  */
3707   return _bfd_elf_is_local_label_name (abfd, name);
3708 }
3709
3710 /* MIPS ELF uses a special find_nearest_line routine in order the
3711    handle the ECOFF debugging information.  */
3712
3713 struct mips_elf_find_line {
3714   struct ecoff_debug_info d;
3715   struct ecoff_find_line i;
3716 };
3717
3718 boolean
3719 _bfd_mips_elf_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
3720                                  functionname_ptr, line_ptr)
3721      bfd *abfd;
3722      asection *section;
3723      asymbol **symbols;
3724      bfd_vma offset;
3725      const char **filename_ptr;
3726      const char **functionname_ptr;
3727      unsigned int *line_ptr;
3728 {
3729   asection *msec;
3730
3731   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
3732                                      filename_ptr, functionname_ptr,
3733                                      line_ptr))
3734     return true;
3735
3736   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
3737                                      filename_ptr, functionname_ptr,
3738                                      line_ptr,
3739                                      ABI_64_P (abfd) ? 8 : 0))
3740     return true;
3741
3742   msec = bfd_get_section_by_name (abfd, ".mdebug");
3743   if (msec != NULL)
3744     {
3745       flagword origflags;
3746       struct mips_elf_find_line *fi;
3747       const struct ecoff_debug_swap * const swap =
3748         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3749
3750       /* If we are called during a link, mips_elf_final_link may have
3751          cleared the SEC_HAS_CONTENTS field.  We force it back on here
3752          if appropriate (which it normally will be).  */
3753       origflags = msec->flags;
3754       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
3755         msec->flags |= SEC_HAS_CONTENTS;
3756
3757       fi = elf_tdata (abfd)->find_line_info;
3758       if (fi == NULL)
3759         {
3760           bfd_size_type external_fdr_size;
3761           char *fraw_src;
3762           char *fraw_end;
3763           struct fdr *fdr_ptr;
3764
3765           fi = ((struct mips_elf_find_line *)
3766                 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
3767           if (fi == NULL)
3768             {
3769               msec->flags = origflags;
3770               return false;
3771             }
3772
3773           if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
3774             {
3775               msec->flags = origflags;
3776               return false;
3777             }
3778
3779           /* Swap in the FDR information.  */
3780           fi->d.fdr = ((struct fdr *)
3781                        bfd_alloc (abfd,
3782                                   (fi->d.symbolic_header.ifdMax *
3783                                    sizeof (struct fdr))));
3784           if (fi->d.fdr == NULL)
3785             {
3786               msec->flags = origflags;
3787               return false;
3788             }
3789           external_fdr_size = swap->external_fdr_size;
3790           fdr_ptr = fi->d.fdr;
3791           fraw_src = (char *) fi->d.external_fdr;
3792           fraw_end = (fraw_src
3793                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
3794           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
3795             (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
3796
3797           elf_tdata (abfd)->find_line_info = fi;
3798
3799           /* Note that we don't bother to ever free this information.
3800              find_nearest_line is either called all the time, as in
3801              objdump -l, so the information should be saved, or it is
3802              rarely called, as in ld error messages, so the memory
3803              wasted is unimportant.  Still, it would probably be a
3804              good idea for free_cached_info to throw it away.  */
3805         }
3806
3807       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
3808                                   &fi->i, filename_ptr, functionname_ptr,
3809                                   line_ptr))
3810         {
3811           msec->flags = origflags;
3812           return true;
3813         }
3814
3815       msec->flags = origflags;
3816     }
3817
3818   /* Fall back on the generic ELF find_nearest_line routine.  */
3819
3820   return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
3821                                      filename_ptr, functionname_ptr,
3822                                      line_ptr);
3823 }
3824 \f
3825   /* The mips16 compiler uses a couple of special sections to handle
3826      floating point arguments.
3827
3828      Section names that look like .mips16.fn.FNNAME contain stubs that
3829      copy floating point arguments from the fp regs to the gp regs and
3830      then jump to FNNAME.  If any 32 bit function calls FNNAME, the
3831      call should be redirected to the stub instead.  If no 32 bit
3832      function calls FNNAME, the stub should be discarded.  We need to
3833      consider any reference to the function, not just a call, because
3834      if the address of the function is taken we will need the stub,
3835      since the address might be passed to a 32 bit function.
3836
3837      Section names that look like .mips16.call.FNNAME contain stubs
3838      that copy floating point arguments from the gp regs to the fp
3839      regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
3840      then any 16 bit function that calls FNNAME should be redirected
3841      to the stub instead.  If FNNAME is not a 32 bit function, the
3842      stub should be discarded.
3843
3844      .mips16.call.fp.FNNAME sections are similar, but contain stubs
3845      which call FNNAME and then copy the return value from the fp regs
3846      to the gp regs.  These stubs store the return value in $18 while
3847      calling FNNAME; any function which might call one of these stubs
3848      must arrange to save $18 around the call.  (This case is not
3849      needed for 32 bit functions that call 16 bit functions, because
3850      16 bit functions always return floating point values in both
3851      $f0/$f1 and $2/$3.)
3852
3853      Note that in all cases FNNAME might be defined statically.
3854      Therefore, FNNAME is not used literally.  Instead, the relocation
3855      information will indicate which symbol the section is for.
3856
3857      We record any stubs that we find in the symbol table.  */
3858
3859 #define FN_STUB ".mips16.fn."
3860 #define CALL_STUB ".mips16.call."
3861 #define CALL_FP_STUB ".mips16.call.fp."
3862
3863 /* MIPS ELF linker hash table.  */
3864
3865 struct mips_elf_link_hash_table {
3866   struct elf_link_hash_table root;
3867 #if 0
3868   /* We no longer use this.  */
3869   /* String section indices for the dynamic section symbols.  */
3870   bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
3871 #endif
3872   /* The number of .rtproc entries.  */
3873   bfd_size_type procedure_count;
3874   /* The size of the .compact_rel section (if SGI_COMPAT).  */
3875   bfd_size_type compact_rel_size;
3876   /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
3877      entry is set to the address of __rld_obj_head as in Irix 5.  */
3878   boolean use_rld_obj_head;
3879   /* This is the value of the __rld_map or __rld_obj_head symbol.  */
3880   bfd_vma rld_value;
3881   /* This is set if we see any mips16 stub sections.  */
3882   boolean mips16_stubs_seen;
3883 };
3884
3885 /* Look up an entry in a MIPS ELF linker hash table.  */
3886
3887 #define mips_elf_link_hash_lookup(table, string, create, copy, follow)  \
3888   ((struct mips_elf_link_hash_entry *)                                  \
3889    elf_link_hash_lookup (&(table)->root, (string), (create),            \
3890                          (copy), (follow)))
3891
3892 /* Traverse a MIPS ELF linker hash table.  */
3893
3894 #define mips_elf_link_hash_traverse(table, func, info)                  \
3895   (elf_link_hash_traverse                                               \
3896    (&(table)->root,                                                     \
3897     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
3898     (info)))
3899
3900 /* Get the MIPS ELF linker hash table from a link_info structure.  */
3901
3902 #define mips_elf_hash_table(p) \
3903   ((struct mips_elf_link_hash_table *) ((p)->hash))
3904
3905 static boolean mips_elf_output_extsym
3906   PARAMS ((struct mips_elf_link_hash_entry *, PTR));
3907
3908 /* Create an entry in a MIPS ELF linker hash table.  */
3909
3910 static struct bfd_hash_entry *
3911 mips_elf_link_hash_newfunc (entry, table, string)
3912      struct bfd_hash_entry *entry;
3913      struct bfd_hash_table *table;
3914      const char *string;
3915 {
3916   struct mips_elf_link_hash_entry *ret =
3917     (struct mips_elf_link_hash_entry *) entry;
3918
3919   /* Allocate the structure if it has not already been allocated by a
3920      subclass.  */
3921   if (ret == (struct mips_elf_link_hash_entry *) NULL)
3922     ret = ((struct mips_elf_link_hash_entry *)
3923            bfd_hash_allocate (table,
3924                               sizeof (struct mips_elf_link_hash_entry)));
3925   if (ret == (struct mips_elf_link_hash_entry *) NULL)
3926     return (struct bfd_hash_entry *) ret;
3927
3928   /* Call the allocation method of the superclass.  */
3929   ret = ((struct mips_elf_link_hash_entry *)
3930          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3931                                      table, string));
3932   if (ret != (struct mips_elf_link_hash_entry *) NULL)
3933     {
3934       /* Set local fields.  */
3935       memset (&ret->esym, 0, sizeof (EXTR));
3936       /* We use -2 as a marker to indicate that the information has
3937          not been set.  -1 means there is no associated ifd.  */
3938       ret->esym.ifd = -2;
3939       ret->possibly_dynamic_relocs = 0;
3940       ret->min_dyn_reloc_index = 0;
3941       ret->fn_stub = NULL;
3942       ret->need_fn_stub = false;
3943       ret->call_stub = NULL;
3944       ret->call_fp_stub = NULL;
3945     }
3946
3947   return (struct bfd_hash_entry *) ret;
3948 }
3949
3950 void
3951 _bfd_mips_elf_hide_symbol (info, h)
3952      struct bfd_link_info *info;
3953      struct mips_elf_link_hash_entry *h;
3954 {
3955   bfd *dynobj;
3956   asection *got;
3957   struct mips_got_info *g;
3958   dynobj = elf_hash_table (info)->dynobj;
3959   got = bfd_get_section_by_name (dynobj, ".got");
3960   g = (struct mips_got_info *) elf_section_data (got)->tdata;
3961
3962   h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3963   h->root.plt.offset = (bfd_vma) -1;
3964   h->root.dynindx = -1;
3965
3966   /* FIXME: Do we allocate too much GOT space here?  */
3967   g->local_gotno++;
3968   got->_raw_size += MIPS_ELF_GOT_SIZE (dynobj);
3969 }
3970
3971 /* Create a MIPS ELF linker hash table.  */
3972
3973 struct bfd_link_hash_table *
3974 _bfd_mips_elf_link_hash_table_create (abfd)
3975      bfd *abfd;
3976 {
3977   struct mips_elf_link_hash_table *ret;
3978
3979   ret = ((struct mips_elf_link_hash_table *)
3980          bfd_alloc (abfd, sizeof (struct mips_elf_link_hash_table)));
3981   if (ret == (struct mips_elf_link_hash_table *) NULL)
3982     return NULL;
3983
3984   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
3985                                        mips_elf_link_hash_newfunc))
3986     {
3987       bfd_release (abfd, ret);
3988       return NULL;
3989     }
3990
3991 #if 0
3992   /* We no longer use this.  */
3993   for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
3994     ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
3995 #endif
3996   ret->procedure_count = 0;
3997   ret->compact_rel_size = 0;
3998   ret->use_rld_obj_head = false;
3999   ret->rld_value = 0;
4000   ret->mips16_stubs_seen = false;
4001
4002   return &ret->root.root;
4003 }
4004
4005 /* Hook called by the linker routine which adds symbols from an object
4006    file.  We must handle the special MIPS section numbers here.  */
4007
4008 boolean
4009 _bfd_mips_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4010      bfd *abfd;
4011      struct bfd_link_info *info;
4012      const Elf_Internal_Sym *sym;
4013      const char **namep;
4014      flagword *flagsp ATTRIBUTE_UNUSED;
4015      asection **secp;
4016      bfd_vma *valp;
4017 {
4018   if (SGI_COMPAT (abfd)
4019       && (abfd->flags & DYNAMIC) != 0
4020       && strcmp (*namep, "_rld_new_interface") == 0)
4021     {
4022       /* Skip Irix 5 rld entry name.  */
4023       *namep = NULL;
4024       return true;
4025     }
4026
4027   switch (sym->st_shndx)
4028     {
4029     case SHN_COMMON:
4030       /* Common symbols less than the GP size are automatically
4031          treated as SHN_MIPS_SCOMMON symbols.  */
4032       if (sym->st_size > elf_gp_size (abfd)
4033           || IRIX_COMPAT (abfd) == ict_irix6)
4034         break;
4035       /* Fall through.  */
4036     case SHN_MIPS_SCOMMON:
4037       *secp = bfd_make_section_old_way (abfd, ".scommon");
4038       (*secp)->flags |= SEC_IS_COMMON;
4039       *valp = sym->st_size;
4040       break;
4041
4042     case SHN_MIPS_TEXT:
4043       /* This section is used in a shared object.  */
4044       if (elf_tdata (abfd)->elf_text_section == NULL)
4045         {
4046           asymbol *elf_text_symbol;
4047           asection *elf_text_section;
4048
4049           elf_text_section = bfd_zalloc (abfd, sizeof (asection));
4050           if (elf_text_section == NULL)
4051             return false;
4052
4053           elf_text_symbol = bfd_zalloc (abfd, sizeof (asymbol));
4054           if (elf_text_symbol == NULL)
4055             return false;
4056
4057           /* Initialize the section.  */
4058
4059           elf_tdata (abfd)->elf_text_section = elf_text_section;
4060           elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
4061
4062           elf_text_section->symbol = elf_text_symbol;
4063           elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
4064
4065           elf_text_section->name = ".text";
4066           elf_text_section->flags = SEC_NO_FLAGS;
4067           elf_text_section->output_section = NULL;
4068           elf_text_section->owner = abfd;
4069           elf_text_symbol->name = ".text";
4070           elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4071           elf_text_symbol->section = elf_text_section;
4072         }
4073       /* This code used to do *secp = bfd_und_section_ptr if
4074          info->shared.  I don't know why, and that doesn't make sense,
4075          so I took it out.  */
4076       *secp = elf_tdata (abfd)->elf_text_section;
4077       break;
4078
4079     case SHN_MIPS_ACOMMON:
4080       /* Fall through. XXX Can we treat this as allocated data?  */
4081     case SHN_MIPS_DATA:
4082       /* This section is used in a shared object.  */
4083       if (elf_tdata (abfd)->elf_data_section == NULL)
4084         {
4085           asymbol *elf_data_symbol;
4086           asection *elf_data_section;
4087
4088           elf_data_section = bfd_zalloc (abfd, sizeof (asection));
4089           if (elf_data_section == NULL)
4090             return false;
4091
4092           elf_data_symbol = bfd_zalloc (abfd, sizeof (asymbol));
4093           if (elf_data_symbol == NULL)
4094             return false;
4095
4096           /* Initialize the section.  */
4097
4098           elf_tdata (abfd)->elf_data_section = elf_data_section;
4099           elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
4100
4101           elf_data_section->symbol = elf_data_symbol;
4102           elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
4103
4104           elf_data_section->name = ".data";
4105           elf_data_section->flags = SEC_NO_FLAGS;
4106           elf_data_section->output_section = NULL;
4107           elf_data_section->owner = abfd;
4108           elf_data_symbol->name = ".data";
4109           elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4110           elf_data_symbol->section = elf_data_section;
4111         }
4112       /* This code used to do *secp = bfd_und_section_ptr if
4113          info->shared.  I don't know why, and that doesn't make sense,
4114          so I took it out.  */
4115       *secp = elf_tdata (abfd)->elf_data_section;
4116       break;
4117
4118     case SHN_MIPS_SUNDEFINED:
4119       *secp = bfd_und_section_ptr;
4120       break;
4121     }
4122
4123   if (SGI_COMPAT (abfd)
4124       && ! info->shared
4125       && info->hash->creator == abfd->xvec
4126       && strcmp (*namep, "__rld_obj_head") == 0)
4127     {
4128       struct elf_link_hash_entry *h;
4129
4130       /* Mark __rld_obj_head as dynamic.  */
4131       h = NULL;
4132       if (! (_bfd_generic_link_add_one_symbol
4133              (info, abfd, *namep, BSF_GLOBAL, *secp,
4134               (bfd_vma) *valp, (const char *) NULL, false,
4135               get_elf_backend_data (abfd)->collect,
4136               (struct bfd_link_hash_entry **) &h)))
4137         return false;
4138       h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4139       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4140       h->type = STT_OBJECT;
4141
4142       if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4143         return false;
4144
4145       mips_elf_hash_table (info)->use_rld_obj_head = true;
4146     }
4147
4148   /* If this is a mips16 text symbol, add 1 to the value to make it
4149      odd.  This will cause something like .word SYM to come up with
4150      the right value when it is loaded into the PC.  */
4151   if (sym->st_other == STO_MIPS16)
4152     ++*valp;
4153
4154   return true;
4155 }
4156
4157 /* Structure used to pass information to mips_elf_output_extsym.  */
4158
4159 struct extsym_info {
4160   bfd *abfd;
4161   struct bfd_link_info *info;
4162   struct ecoff_debug_info *debug;
4163   const struct ecoff_debug_swap *swap;
4164   boolean failed;
4165 };
4166
4167 /* This routine is used to write out ECOFF debugging external symbol
4168    information.  It is called via mips_elf_link_hash_traverse.  The
4169    ECOFF external symbol information must match the ELF external
4170    symbol information.  Unfortunately, at this point we don't know
4171    whether a symbol is required by reloc information, so the two
4172    tables may wind up being different.  We must sort out the external
4173    symbol information before we can set the final size of the .mdebug
4174    section, and we must set the size of the .mdebug section before we
4175    can relocate any sections, and we can't know which symbols are
4176    required by relocation until we relocate the sections.
4177    Fortunately, it is relatively unlikely that any symbol will be
4178    stripped but required by a reloc.  In particular, it can not happen
4179    when generating a final executable.  */
4180
4181 static boolean
4182 mips_elf_output_extsym (h, data)
4183      struct mips_elf_link_hash_entry *h;
4184      PTR data;
4185 {
4186   struct extsym_info *einfo = (struct extsym_info *) data;
4187   boolean strip;
4188   asection *sec, *output_section;
4189
4190   if (h->root.indx == -2)
4191     strip = false;
4192   else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4193             || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
4194            && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
4195            && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
4196     strip = true;
4197   else if (einfo->info->strip == strip_all
4198            || (einfo->info->strip == strip_some
4199                && bfd_hash_lookup (einfo->info->keep_hash,
4200                                    h->root.root.root.string,
4201                                    false, false) == NULL))
4202     strip = true;
4203   else
4204     strip = false;
4205
4206   if (strip)
4207     return true;
4208
4209   if (h->esym.ifd == -2)
4210     {
4211       h->esym.jmptbl = 0;
4212       h->esym.cobol_main = 0;
4213       h->esym.weakext = 0;
4214       h->esym.reserved = 0;
4215       h->esym.ifd = ifdNil;
4216       h->esym.asym.value = 0;
4217       h->esym.asym.st = stGlobal;
4218
4219       if (h->root.root.type == bfd_link_hash_undefined
4220           || h->root.root.type == bfd_link_hash_undefweak)
4221         {
4222           const char *name;
4223
4224           /* Use undefined class.  Also, set class and type for some
4225              special symbols.  */
4226           name = h->root.root.root.string;
4227           if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
4228               || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
4229             {
4230               h->esym.asym.sc = scData;
4231               h->esym.asym.st = stLabel;
4232               h->esym.asym.value = 0;
4233             }
4234           else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
4235             {
4236               h->esym.asym.sc = scAbs;
4237               h->esym.asym.st = stLabel;
4238               h->esym.asym.value =
4239                 mips_elf_hash_table (einfo->info)->procedure_count;
4240             }
4241           else if (strcmp (name, "_gp_disp") == 0)
4242             {
4243               h->esym.asym.sc = scAbs;
4244               h->esym.asym.st = stLabel;
4245               h->esym.asym.value = elf_gp (einfo->abfd);
4246             }
4247           else
4248             h->esym.asym.sc = scUndefined;
4249         }
4250       else if (h->root.root.type != bfd_link_hash_defined
4251           && h->root.root.type != bfd_link_hash_defweak)
4252         h->esym.asym.sc = scAbs;
4253       else
4254         {
4255           const char *name;
4256
4257           sec = h->root.root.u.def.section;
4258           output_section = sec->output_section;
4259
4260           /* When making a shared library and symbol h is the one from
4261              the another shared library, OUTPUT_SECTION may be null.  */
4262           if (output_section == NULL)
4263             h->esym.asym.sc = scUndefined;
4264           else
4265             {
4266               name = bfd_section_name (output_section->owner, output_section);
4267
4268               if (strcmp (name, ".text") == 0)
4269                 h->esym.asym.sc = scText;
4270               else if (strcmp (name, ".data") == 0)
4271                 h->esym.asym.sc = scData;
4272               else if (strcmp (name, ".sdata") == 0)
4273                 h->esym.asym.sc = scSData;
4274               else if (strcmp (name, ".rodata") == 0
4275                        || strcmp (name, ".rdata") == 0)
4276                 h->esym.asym.sc = scRData;
4277               else if (strcmp (name, ".bss") == 0)
4278                 h->esym.asym.sc = scBss;
4279               else if (strcmp (name, ".sbss") == 0)
4280                 h->esym.asym.sc = scSBss;
4281               else if (strcmp (name, ".init") == 0)
4282                 h->esym.asym.sc = scInit;
4283               else if (strcmp (name, ".fini") == 0)
4284                 h->esym.asym.sc = scFini;
4285               else
4286                 h->esym.asym.sc = scAbs;
4287             }
4288         }
4289
4290       h->esym.asym.reserved = 0;
4291       h->esym.asym.index = indexNil;
4292     }
4293
4294   if (h->root.root.type == bfd_link_hash_common)
4295     h->esym.asym.value = h->root.root.u.c.size;
4296   else if (h->root.root.type == bfd_link_hash_defined
4297            || h->root.root.type == bfd_link_hash_defweak)
4298     {
4299       if (h->esym.asym.sc == scCommon)
4300         h->esym.asym.sc = scBss;
4301       else if (h->esym.asym.sc == scSCommon)
4302         h->esym.asym.sc = scSBss;
4303
4304       sec = h->root.root.u.def.section;
4305       output_section = sec->output_section;
4306       if (output_section != NULL)
4307         h->esym.asym.value = (h->root.root.u.def.value
4308                               + sec->output_offset
4309                               + output_section->vma);
4310       else
4311         h->esym.asym.value = 0;
4312     }
4313   else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
4314     {
4315       /* Set type and value for a symbol with a function stub.  */
4316       h->esym.asym.st = stProc;
4317       sec = h->root.root.u.def.section;
4318       if (sec == NULL)
4319         h->esym.asym.value = 0;
4320       else
4321         {
4322           output_section = sec->output_section;
4323           if (output_section != NULL)
4324             h->esym.asym.value = (h->root.plt.offset
4325                                   + sec->output_offset
4326                                   + output_section->vma);
4327           else
4328             h->esym.asym.value = 0;
4329         }
4330 #if 0 /* FIXME?  */
4331       h->esym.ifd = 0;
4332 #endif
4333     }
4334
4335   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
4336                                       h->root.root.root.string,
4337                                       &h->esym))
4338     {
4339       einfo->failed = true;
4340       return false;
4341     }
4342
4343   return true;
4344 }
4345
4346 /* Create a runtime procedure table from the .mdebug section.  */
4347
4348 static boolean
4349 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
4350      PTR handle;
4351      bfd *abfd;
4352      struct bfd_link_info *info;
4353      asection *s;
4354      struct ecoff_debug_info *debug;
4355 {
4356   const struct ecoff_debug_swap *swap;
4357   HDRR *hdr = &debug->symbolic_header;
4358   RPDR *rpdr, *rp;
4359   struct rpdr_ext *erp;
4360   PTR rtproc;
4361   struct pdr_ext *epdr;
4362   struct sym_ext *esym;
4363   char *ss, **sv;
4364   char *str;
4365   unsigned long size, count;
4366   unsigned long sindex;
4367   unsigned long i;
4368   PDR pdr;
4369   SYMR sym;
4370   const char *no_name_func = _("static procedure (no name)");
4371
4372   epdr = NULL;
4373   rpdr = NULL;
4374   esym = NULL;
4375   ss = NULL;
4376   sv = NULL;
4377
4378   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4379
4380   sindex = strlen (no_name_func) + 1;
4381   count = hdr->ipdMax;
4382   if (count > 0)
4383     {
4384       size = swap->external_pdr_size;
4385
4386       epdr = (struct pdr_ext *) bfd_malloc (size * count);
4387       if (epdr == NULL)
4388         goto error_return;
4389
4390       if (! _bfd_ecoff_get_accumulated_pdr (handle, (PTR) epdr))
4391         goto error_return;
4392
4393       size = sizeof (RPDR);
4394       rp = rpdr = (RPDR *) bfd_malloc (size * count);
4395       if (rpdr == NULL)
4396         goto error_return;
4397
4398       sv = (char **) bfd_malloc (sizeof (char *) * count);
4399       if (sv == NULL)
4400         goto error_return;
4401
4402       count = hdr->isymMax;
4403       size = swap->external_sym_size;
4404       esym = (struct sym_ext *) bfd_malloc (size * count);
4405       if (esym == NULL)
4406         goto error_return;
4407
4408       if (! _bfd_ecoff_get_accumulated_sym (handle, (PTR) esym))
4409         goto error_return;
4410
4411       count = hdr->issMax;
4412       ss = (char *) bfd_malloc (count);
4413       if (ss == NULL)
4414         goto error_return;
4415       if (! _bfd_ecoff_get_accumulated_ss (handle, (PTR) ss))
4416         goto error_return;
4417
4418       count = hdr->ipdMax;
4419       for (i = 0; i < count; i++, rp++)
4420         {
4421           (*swap->swap_pdr_in) (abfd, (PTR) (epdr + i), &pdr);
4422           (*swap->swap_sym_in) (abfd, (PTR) &esym[pdr.isym], &sym);
4423           rp->adr = sym.value;
4424           rp->regmask = pdr.regmask;
4425           rp->regoffset = pdr.regoffset;
4426           rp->fregmask = pdr.fregmask;
4427           rp->fregoffset = pdr.fregoffset;
4428           rp->frameoffset = pdr.frameoffset;
4429           rp->framereg = pdr.framereg;
4430           rp->pcreg = pdr.pcreg;
4431           rp->irpss = sindex;
4432           sv[i] = ss + sym.iss;
4433           sindex += strlen (sv[i]) + 1;
4434         }
4435     }
4436
4437   size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
4438   size = BFD_ALIGN (size, 16);
4439   rtproc = (PTR) bfd_alloc (abfd, size);
4440   if (rtproc == NULL)
4441     {
4442       mips_elf_hash_table (info)->procedure_count = 0;
4443       goto error_return;
4444     }
4445
4446   mips_elf_hash_table (info)->procedure_count = count + 2;
4447
4448   erp = (struct rpdr_ext *) rtproc;
4449   memset (erp, 0, sizeof (struct rpdr_ext));
4450   erp++;
4451   str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
4452   strcpy (str, no_name_func);
4453   str += strlen (no_name_func) + 1;
4454   for (i = 0; i < count; i++)
4455     {
4456       ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
4457       strcpy (str, sv[i]);
4458       str += strlen (sv[i]) + 1;
4459     }
4460   ecoff_put_off (abfd, (bfd_vma) -1, (bfd_byte *) (erp + count)->p_adr);
4461
4462   /* Set the size and contents of .rtproc section.  */
4463   s->_raw_size = size;
4464   s->contents = (bfd_byte *) rtproc;
4465
4466   /* Skip this section later on (I don't think this currently
4467      matters, but someday it might).  */
4468   s->link_order_head = (struct bfd_link_order *) NULL;
4469
4470   if (epdr != NULL)
4471     free (epdr);
4472   if (rpdr != NULL)
4473     free (rpdr);
4474   if (esym != NULL)
4475     free (esym);
4476   if (ss != NULL)
4477     free (ss);
4478   if (sv != NULL)
4479     free (sv);
4480
4481   return true;
4482
4483  error_return:
4484   if (epdr != NULL)
4485     free (epdr);
4486   if (rpdr != NULL)
4487     free (rpdr);
4488   if (esym != NULL)
4489     free (esym);
4490   if (ss != NULL)
4491     free (ss);
4492   if (sv != NULL)
4493     free (sv);
4494   return false;
4495 }
4496
4497 /* A comparison routine used to sort .gptab entries.  */
4498
4499 static int
4500 gptab_compare (p1, p2)
4501      const PTR p1;
4502      const PTR p2;
4503 {
4504   const Elf32_gptab *a1 = (const Elf32_gptab *) p1;
4505   const Elf32_gptab *a2 = (const Elf32_gptab *) p2;
4506
4507   return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
4508 }
4509
4510 /* We need to use a special link routine to handle the .reginfo and
4511    the .mdebug sections.  We need to merge all instances of these
4512    sections together, not write them all out sequentially.  */
4513
4514 boolean
4515 _bfd_mips_elf_final_link (abfd, info)
4516      bfd *abfd;
4517      struct bfd_link_info *info;
4518 {
4519   asection **secpp;
4520   asection *o;
4521   struct bfd_link_order *p;
4522   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
4523   asection *rtproc_sec;
4524   Elf32_RegInfo reginfo;
4525   struct ecoff_debug_info debug;
4526   const struct ecoff_debug_swap *swap
4527     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4528   HDRR *symhdr = &debug.symbolic_header;
4529   PTR mdebug_handle = NULL;
4530   asection *s;
4531   EXTR esym;
4532   bfd_vma last;
4533   unsigned int i;
4534   static const char * const name[] = {
4535     ".text", ".init", ".fini", ".data",
4536     ".rodata", ".sdata", ".sbss", ".bss"
4537   };
4538   static const int sc[] = {
4539     scText, scInit, scFini, scData,
4540     scRData, scSData, scSBss, scBss
4541   };
4542
4543   /* If all the things we linked together were PIC, but we're
4544      producing an executable (rather than a shared object), then the
4545      resulting file is CPIC (i.e., it calls PIC code.)  */
4546   if (!info->shared
4547       && !info->relocateable
4548       && elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
4549     {
4550       elf_elfheader (abfd)->e_flags &= ~EF_MIPS_PIC;
4551       elf_elfheader (abfd)->e_flags |= EF_MIPS_CPIC;
4552     }
4553
4554   /* We'd carefully arranged the dynamic symbol indices, and then the
4555      generic size_dynamic_sections renumbered them out from under us.
4556      Rather than trying somehow to prevent the renumbering, just do
4557      the sort again.  */
4558   if (elf_hash_table (info)->dynamic_sections_created)
4559     {
4560       bfd *dynobj;
4561       asection *got;
4562       struct mips_got_info *g;
4563
4564       /* When we resort, we must tell mips_elf_sort_hash_table what
4565          the lowest index it may use is.  That's the number of section
4566          symbols we're going to add.  The generic ELF linker only
4567          adds these symbols when building a shared object.  Note that
4568          we count the sections after (possibly) removing the .options
4569          section above.  */
4570       if (!mips_elf_sort_hash_table (info, (info->shared
4571                                             ? bfd_count_sections (abfd) + 1
4572                                             : 1)))
4573         return false;
4574
4575       /* Make sure we didn't grow the global .got region.  */
4576       dynobj = elf_hash_table (info)->dynobj;
4577       got = bfd_get_section_by_name (dynobj, ".got");
4578       g = (struct mips_got_info *) elf_section_data (got)->tdata;
4579
4580       if (g->global_gotsym != NULL)
4581         BFD_ASSERT ((elf_hash_table (info)->dynsymcount
4582                      - g->global_gotsym->dynindx)
4583                     <= g->global_gotno);
4584     }
4585
4586   /* On IRIX5, we omit the .options section.  On IRIX6, however, we
4587      include it, even though we don't process it quite right.  (Some
4588      entries are supposed to be merged.)  Empirically, we seem to be
4589      better off including it then not.  */
4590   if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
4591     for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
4592       {
4593         if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
4594           {
4595             for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
4596               if (p->type == bfd_indirect_link_order)
4597                 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
4598             (*secpp)->link_order_head = NULL;
4599             *secpp = (*secpp)->next;
4600             --abfd->section_count;
4601
4602             break;
4603           }
4604       }
4605
4606   /* Get a value for the GP register.  */
4607   if (elf_gp (abfd) == 0)
4608     {
4609       struct bfd_link_hash_entry *h;
4610
4611       h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
4612       if (h != (struct bfd_link_hash_entry *) NULL
4613           && h->type == bfd_link_hash_defined)
4614         elf_gp (abfd) = (h->u.def.value
4615                          + h->u.def.section->output_section->vma
4616                          + h->u.def.section->output_offset);
4617       else if (info->relocateable)
4618         {
4619           bfd_vma lo;
4620
4621           /* Find the GP-relative section with the lowest offset.  */
4622           lo = (bfd_vma) -1;
4623           for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4624             if (o->vma < lo
4625                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
4626               lo = o->vma;
4627
4628           /* And calculate GP relative to that.  */
4629           elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
4630         }
4631       else
4632         {
4633           /* If the relocate_section function needs to do a reloc
4634              involving the GP value, it should make a reloc_dangerous
4635              callback to warn that GP is not defined.  */
4636         }
4637     }
4638
4639   /* Go through the sections and collect the .reginfo and .mdebug
4640      information.  */
4641   reginfo_sec = NULL;
4642   mdebug_sec = NULL;
4643   gptab_data_sec = NULL;
4644   gptab_bss_sec = NULL;
4645   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4646     {
4647       if (strcmp (o->name, ".reginfo") == 0)
4648         {
4649           memset (&reginfo, 0, sizeof reginfo);
4650
4651           /* We have found the .reginfo section in the output file.
4652              Look through all the link_orders comprising it and merge
4653              the information together.  */
4654           for (p = o->link_order_head;
4655                p != (struct bfd_link_order *) NULL;
4656                p = p->next)
4657             {
4658               asection *input_section;
4659               bfd *input_bfd;
4660               Elf32_External_RegInfo ext;
4661               Elf32_RegInfo sub;
4662
4663               if (p->type != bfd_indirect_link_order)
4664                 {
4665                   if (p->type == bfd_fill_link_order)
4666                     continue;
4667                   abort ();
4668                 }
4669
4670               input_section = p->u.indirect.section;
4671               input_bfd = input_section->owner;
4672
4673               /* The linker emulation code has probably clobbered the
4674                  size to be zero bytes.  */
4675               if (input_section->_raw_size == 0)
4676                 input_section->_raw_size = sizeof (Elf32_External_RegInfo);
4677
4678               if (! bfd_get_section_contents (input_bfd, input_section,
4679                                               (PTR) &ext,
4680                                               (file_ptr) 0,
4681                                               sizeof ext))
4682                 return false;
4683
4684               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
4685
4686               reginfo.ri_gprmask |= sub.ri_gprmask;
4687               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4688               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4689               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4690               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4691
4692               /* ri_gp_value is set by the function
4693                  mips_elf32_section_processing when the section is
4694                  finally written out.  */
4695
4696               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4697                  elf_link_input_bfd ignores this section.  */
4698               input_section->flags &= ~SEC_HAS_CONTENTS;
4699             }
4700
4701           /* Size has been set in mips_elf_always_size_sections  */
4702           BFD_ASSERT(o->_raw_size == sizeof (Elf32_External_RegInfo));
4703
4704           /* Skip this section later on (I don't think this currently
4705              matters, but someday it might).  */
4706           o->link_order_head = (struct bfd_link_order *) NULL;
4707
4708           reginfo_sec = o;
4709         }
4710
4711       if (strcmp (o->name, ".mdebug") == 0)
4712         {
4713           struct extsym_info einfo;
4714
4715           /* We have found the .mdebug section in the output file.
4716              Look through all the link_orders comprising it and merge
4717              the information together.  */
4718           symhdr->magic = swap->sym_magic;
4719           /* FIXME: What should the version stamp be?  */
4720           symhdr->vstamp = 0;
4721           symhdr->ilineMax = 0;
4722           symhdr->cbLine = 0;
4723           symhdr->idnMax = 0;
4724           symhdr->ipdMax = 0;
4725           symhdr->isymMax = 0;
4726           symhdr->ioptMax = 0;
4727           symhdr->iauxMax = 0;
4728           symhdr->issMax = 0;
4729           symhdr->issExtMax = 0;
4730           symhdr->ifdMax = 0;
4731           symhdr->crfd = 0;
4732           symhdr->iextMax = 0;
4733
4734           /* We accumulate the debugging information itself in the
4735              debug_info structure.  */
4736           debug.line = NULL;
4737           debug.external_dnr = NULL;
4738           debug.external_pdr = NULL;
4739           debug.external_sym = NULL;
4740           debug.external_opt = NULL;
4741           debug.external_aux = NULL;
4742           debug.ss = NULL;
4743           debug.ssext = debug.ssext_end = NULL;
4744           debug.external_fdr = NULL;
4745           debug.external_rfd = NULL;
4746           debug.external_ext = debug.external_ext_end = NULL;
4747
4748           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4749           if (mdebug_handle == (PTR) NULL)
4750             return false;
4751
4752           esym.jmptbl = 0;
4753           esym.cobol_main = 0;
4754           esym.weakext = 0;
4755           esym.reserved = 0;
4756           esym.ifd = ifdNil;
4757           esym.asym.iss = issNil;
4758           esym.asym.st = stLocal;
4759           esym.asym.reserved = 0;
4760           esym.asym.index = indexNil;
4761           last = 0;
4762           for (i = 0; i < 8; i++)
4763             {
4764               esym.asym.sc = sc[i];
4765               s = bfd_get_section_by_name (abfd, name[i]);
4766               if (s != NULL)
4767                 {
4768                   esym.asym.value = s->vma;
4769                   last = s->vma + s->_raw_size;
4770                 }
4771               else
4772                 esym.asym.value = last;
4773               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
4774                                                  name[i], &esym))
4775                 return false;
4776             }
4777
4778           for (p = o->link_order_head;
4779                p != (struct bfd_link_order *) NULL;
4780                p = p->next)
4781             {
4782               asection *input_section;
4783               bfd *input_bfd;
4784               const struct ecoff_debug_swap *input_swap;
4785               struct ecoff_debug_info input_debug;
4786               char *eraw_src;
4787               char *eraw_end;
4788
4789               if (p->type != bfd_indirect_link_order)
4790                 {
4791                   if (p->type == bfd_fill_link_order)
4792                     continue;
4793                   abort ();
4794                 }
4795
4796               input_section = p->u.indirect.section;
4797               input_bfd = input_section->owner;
4798
4799               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4800                   || (get_elf_backend_data (input_bfd)
4801                       ->elf_backend_ecoff_debug_swap) == NULL)
4802                 {
4803                   /* I don't know what a non MIPS ELF bfd would be
4804                      doing with a .mdebug section, but I don't really
4805                      want to deal with it.  */
4806                   continue;
4807                 }
4808
4809               input_swap = (get_elf_backend_data (input_bfd)
4810                             ->elf_backend_ecoff_debug_swap);
4811
4812               BFD_ASSERT (p->size == input_section->_raw_size);
4813
4814               /* The ECOFF linking code expects that we have already
4815                  read in the debugging information and set up an
4816                  ecoff_debug_info structure, so we do that now.  */
4817               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
4818                                                    &input_debug))
4819                 return false;
4820
4821               if (! (bfd_ecoff_debug_accumulate
4822                      (mdebug_handle, abfd, &debug, swap, input_bfd,
4823                       &input_debug, input_swap, info)))
4824                 return false;
4825
4826               /* Loop through the external symbols.  For each one with
4827                  interesting information, try to find the symbol in
4828                  the linker global hash table and save the information
4829                  for the output external symbols.  */
4830               eraw_src = input_debug.external_ext;
4831               eraw_end = (eraw_src
4832                           + (input_debug.symbolic_header.iextMax
4833                              * input_swap->external_ext_size));
4834               for (;
4835                    eraw_src < eraw_end;
4836                    eraw_src += input_swap->external_ext_size)
4837                 {
4838                   EXTR ext;
4839                   const char *name;
4840                   struct mips_elf_link_hash_entry *h;
4841
4842                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4843                   if (ext.asym.sc == scNil
4844                       || ext.asym.sc == scUndefined
4845                       || ext.asym.sc == scSUndefined)
4846                     continue;
4847
4848                   name = input_debug.ssext + ext.asym.iss;
4849                   h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
4850                                                  name, false, false, true);
4851                   if (h == NULL || h->esym.ifd != -2)
4852                     continue;
4853
4854                   if (ext.ifd != -1)
4855                     {
4856                       BFD_ASSERT (ext.ifd
4857                                   < input_debug.symbolic_header.ifdMax);
4858                       ext.ifd = input_debug.ifdmap[ext.ifd];
4859                     }
4860
4861                   h->esym = ext;
4862                 }
4863
4864               /* Free up the information we just read.  */
4865               free (input_debug.line);
4866               free (input_debug.external_dnr);
4867               free (input_debug.external_pdr);
4868               free (input_debug.external_sym);
4869               free (input_debug.external_opt);
4870               free (input_debug.external_aux);
4871               free (input_debug.ss);
4872               free (input_debug.ssext);
4873               free (input_debug.external_fdr);
4874               free (input_debug.external_rfd);
4875               free (input_debug.external_ext);
4876
4877               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4878                  elf_link_input_bfd ignores this section.  */
4879               input_section->flags &= ~SEC_HAS_CONTENTS;
4880             }
4881
4882           if (SGI_COMPAT (abfd) && info->shared)
4883             {
4884               /* Create .rtproc section.  */
4885               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4886               if (rtproc_sec == NULL)
4887                 {
4888                   flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
4889                                     | SEC_LINKER_CREATED | SEC_READONLY);
4890
4891                   rtproc_sec = bfd_make_section (abfd, ".rtproc");
4892                   if (rtproc_sec == NULL
4893                       || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4894                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
4895                     return false;
4896                 }
4897
4898               if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
4899                                                      info, rtproc_sec, &debug))
4900                 return false;
4901             }
4902
4903           /* Build the external symbol information.  */
4904           einfo.abfd = abfd;
4905           einfo.info = info;
4906           einfo.debug = &debug;
4907           einfo.swap = swap;
4908           einfo.failed = false;
4909           mips_elf_link_hash_traverse (mips_elf_hash_table (info),
4910                                        mips_elf_output_extsym,
4911                                        (PTR) &einfo);
4912           if (einfo.failed)
4913             return false;
4914
4915           /* Set the size of the .mdebug section.  */
4916           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4917
4918           /* Skip this section later on (I don't think this currently
4919              matters, but someday it might).  */
4920           o->link_order_head = (struct bfd_link_order *) NULL;
4921
4922           mdebug_sec = o;
4923         }
4924
4925       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4926         {
4927           const char *subname;
4928           unsigned int c;
4929           Elf32_gptab *tab;
4930           Elf32_External_gptab *ext_tab;
4931           unsigned int i;
4932
4933           /* The .gptab.sdata and .gptab.sbss sections hold
4934              information describing how the small data area would
4935              change depending upon the -G switch.  These sections
4936              not used in executables files.  */
4937           if (! info->relocateable)
4938             {
4939               asection **secpp;
4940
4941               for (p = o->link_order_head;
4942                    p != (struct bfd_link_order *) NULL;
4943                    p = p->next)
4944                 {
4945                   asection *input_section;
4946
4947                   if (p->type != bfd_indirect_link_order)
4948                     {
4949                       if (p->type == bfd_fill_link_order)
4950                         continue;
4951                       abort ();
4952                     }
4953
4954                   input_section = p->u.indirect.section;
4955
4956                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
4957                      elf_link_input_bfd ignores this section.  */
4958                   input_section->flags &= ~SEC_HAS_CONTENTS;
4959                 }
4960
4961               /* Skip this section later on (I don't think this
4962                  currently matters, but someday it might).  */
4963               o->link_order_head = (struct bfd_link_order *) NULL;
4964
4965               /* Really remove the section.  */
4966               for (secpp = &abfd->sections;
4967                    *secpp != o;
4968                    secpp = &(*secpp)->next)
4969                 ;
4970               *secpp = (*secpp)->next;
4971               --abfd->section_count;
4972
4973               continue;
4974             }
4975
4976           /* There is one gptab for initialized data, and one for
4977              uninitialized data.  */
4978           if (strcmp (o->name, ".gptab.sdata") == 0)
4979             gptab_data_sec = o;
4980           else if (strcmp (o->name, ".gptab.sbss") == 0)
4981             gptab_bss_sec = o;
4982           else
4983             {
4984               (*_bfd_error_handler)
4985                 (_("%s: illegal section name `%s'"),
4986                  bfd_get_filename (abfd), o->name);
4987               bfd_set_error (bfd_error_nonrepresentable_section);
4988               return false;
4989             }
4990
4991           /* The linker script always combines .gptab.data and
4992              .gptab.sdata into .gptab.sdata, and likewise for
4993              .gptab.bss and .gptab.sbss.  It is possible that there is
4994              no .sdata or .sbss section in the output file, in which
4995              case we must change the name of the output section.  */
4996           subname = o->name + sizeof ".gptab" - 1;
4997           if (bfd_get_section_by_name (abfd, subname) == NULL)
4998             {
4999               if (o == gptab_data_sec)
5000                 o->name = ".gptab.data";
5001               else
5002                 o->name = ".gptab.bss";
5003               subname = o->name + sizeof ".gptab" - 1;
5004               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
5005             }
5006
5007           /* Set up the first entry.  */
5008           c = 1;
5009           tab = (Elf32_gptab *) bfd_malloc (c * sizeof (Elf32_gptab));
5010           if (tab == NULL)
5011             return false;
5012           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
5013           tab[0].gt_header.gt_unused = 0;
5014
5015           /* Combine the input sections.  */
5016           for (p = o->link_order_head;
5017                p != (struct bfd_link_order *) NULL;
5018                p = p->next)
5019             {
5020               asection *input_section;
5021               bfd *input_bfd;
5022               bfd_size_type size;
5023               unsigned long last;
5024               bfd_size_type gpentry;
5025
5026               if (p->type != bfd_indirect_link_order)
5027                 {
5028                   if (p->type == bfd_fill_link_order)
5029                     continue;
5030                   abort ();
5031                 }
5032
5033               input_section = p->u.indirect.section;
5034               input_bfd = input_section->owner;
5035
5036               /* Combine the gptab entries for this input section one
5037                  by one.  We know that the input gptab entries are
5038                  sorted by ascending -G value.  */
5039               size = bfd_section_size (input_bfd, input_section);
5040               last = 0;
5041               for (gpentry = sizeof (Elf32_External_gptab);
5042                    gpentry < size;
5043                    gpentry += sizeof (Elf32_External_gptab))
5044                 {
5045                   Elf32_External_gptab ext_gptab;
5046                   Elf32_gptab int_gptab;
5047                   unsigned long val;
5048                   unsigned long add;
5049                   boolean exact;
5050                   unsigned int look;
5051
5052                   if (! (bfd_get_section_contents
5053                          (input_bfd, input_section, (PTR) &ext_gptab,
5054                           gpentry, sizeof (Elf32_External_gptab))))
5055                     {
5056                       free (tab);
5057                       return false;
5058                     }
5059
5060                   bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
5061                                                 &int_gptab);
5062                   val = int_gptab.gt_entry.gt_g_value;
5063                   add = int_gptab.gt_entry.gt_bytes - last;
5064
5065                   exact = false;
5066                   for (look = 1; look < c; look++)
5067                     {
5068                       if (tab[look].gt_entry.gt_g_value >= val)
5069                         tab[look].gt_entry.gt_bytes += add;
5070
5071                       if (tab[look].gt_entry.gt_g_value == val)
5072                         exact = true;
5073                     }
5074
5075                   if (! exact)
5076                     {
5077                       Elf32_gptab *new_tab;
5078                       unsigned int max;
5079
5080                       /* We need a new table entry.  */
5081                       new_tab = ((Elf32_gptab *)
5082                                  bfd_realloc ((PTR) tab,
5083                                               (c + 1) * sizeof (Elf32_gptab)));
5084                       if (new_tab == NULL)
5085                         {
5086                           free (tab);
5087                           return false;
5088                         }
5089                       tab = new_tab;
5090                       tab[c].gt_entry.gt_g_value = val;
5091                       tab[c].gt_entry.gt_bytes = add;
5092
5093                       /* Merge in the size for the next smallest -G
5094                          value, since that will be implied by this new
5095                          value.  */
5096                       max = 0;
5097                       for (look = 1; look < c; look++)
5098                         {
5099                           if (tab[look].gt_entry.gt_g_value < val
5100                               && (max == 0
5101                                   || (tab[look].gt_entry.gt_g_value
5102                                       > tab[max].gt_entry.gt_g_value)))
5103                             max = look;
5104                         }
5105                       if (max != 0)
5106                         tab[c].gt_entry.gt_bytes +=
5107                           tab[max].gt_entry.gt_bytes;
5108
5109                       ++c;
5110                     }
5111
5112                   last = int_gptab.gt_entry.gt_bytes;
5113                 }
5114
5115               /* Hack: reset the SEC_HAS_CONTENTS flag so that
5116                  elf_link_input_bfd ignores this section.  */
5117               input_section->flags &= ~SEC_HAS_CONTENTS;
5118             }
5119
5120           /* The table must be sorted by -G value.  */
5121           if (c > 2)
5122             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
5123
5124           /* Swap out the table.  */
5125           ext_tab = ((Elf32_External_gptab *)
5126                      bfd_alloc (abfd, c * sizeof (Elf32_External_gptab)));
5127           if (ext_tab == NULL)
5128             {
5129               free (tab);
5130               return false;
5131             }
5132
5133           for (i = 0; i < c; i++)
5134             bfd_mips_elf32_swap_gptab_out (abfd, tab + i, ext_tab + i);
5135           free (tab);
5136
5137           o->_raw_size = c * sizeof (Elf32_External_gptab);
5138           o->contents = (bfd_byte *) ext_tab;
5139
5140           /* Skip this section later on (I don't think this currently
5141              matters, but someday it might).  */
5142           o->link_order_head = (struct bfd_link_order *) NULL;
5143         }
5144     }
5145
5146   /* Invoke the regular ELF backend linker to do all the work.  */
5147   if (ABI_64_P (abfd))
5148     {
5149 #ifdef BFD64
5150       if (!bfd_elf64_bfd_final_link (abfd, info))
5151         return false;
5152 #else
5153       abort ();
5154       return false;
5155 #endif /* BFD64 */
5156     }
5157   else if (!bfd_elf32_bfd_final_link (abfd, info))
5158     return false;
5159
5160   /* Now write out the computed sections.  */
5161
5162   if (reginfo_sec != (asection *) NULL)
5163     {
5164       Elf32_External_RegInfo ext;
5165
5166       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
5167       if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
5168                                       (file_ptr) 0, sizeof ext))
5169         return false;
5170     }
5171
5172   if (mdebug_sec != (asection *) NULL)
5173     {
5174       BFD_ASSERT (abfd->output_has_begun);
5175       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5176                                                swap, info,
5177                                                mdebug_sec->filepos))
5178         return false;
5179
5180       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5181     }
5182
5183   if (gptab_data_sec != (asection *) NULL)
5184     {
5185       if (! bfd_set_section_contents (abfd, gptab_data_sec,
5186                                       gptab_data_sec->contents,
5187                                       (file_ptr) 0,
5188                                       gptab_data_sec->_raw_size))
5189         return false;
5190     }
5191
5192   if (gptab_bss_sec != (asection *) NULL)
5193     {
5194       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
5195                                       gptab_bss_sec->contents,
5196                                       (file_ptr) 0,
5197                                       gptab_bss_sec->_raw_size))
5198         return false;
5199     }
5200
5201   if (SGI_COMPAT (abfd))
5202     {
5203       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
5204       if (rtproc_sec != NULL)
5205         {
5206           if (! bfd_set_section_contents (abfd, rtproc_sec,
5207                                           rtproc_sec->contents,
5208                                           (file_ptr) 0,
5209                                           rtproc_sec->_raw_size))
5210             return false;
5211         }
5212     }
5213
5214   return true;
5215 }
5216
5217 /* This function is called via qsort() to sort the dynamic relocation
5218    entries by increasing r_symndx value.  */
5219
5220 static int
5221 sort_dynamic_relocs (arg1, arg2)
5222      const PTR arg1;
5223      const PTR arg2;
5224 {
5225   const Elf32_External_Rel *ext_reloc1 = (const Elf32_External_Rel *) arg1;
5226   const Elf32_External_Rel *ext_reloc2 = (const Elf32_External_Rel *) arg2;
5227
5228   Elf_Internal_Rel int_reloc1;
5229   Elf_Internal_Rel int_reloc2;
5230
5231   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, ext_reloc1, &int_reloc1);
5232   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, ext_reloc2, &int_reloc2);
5233
5234   return (ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info));
5235 }
5236
5237 /* Returns the GOT section for ABFD.  */
5238
5239 static asection *
5240 mips_elf_got_section (abfd)
5241      bfd *abfd;
5242 {
5243   return bfd_get_section_by_name (abfd, ".got");
5244 }
5245
5246 /* Returns the GOT information associated with the link indicated by
5247    INFO.  If SGOTP is non-NULL, it is filled in with the GOT
5248    section.  */
5249
5250 static struct mips_got_info *
5251 mips_elf_got_info (abfd, sgotp)
5252      bfd *abfd;
5253      asection **sgotp;
5254 {
5255   asection *sgot;
5256   struct mips_got_info *g;
5257
5258   sgot = mips_elf_got_section (abfd);
5259   BFD_ASSERT (sgot != NULL);
5260   BFD_ASSERT (elf_section_data (sgot) != NULL);
5261   g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
5262   BFD_ASSERT (g != NULL);
5263
5264   if (sgotp)
5265     *sgotp = sgot;
5266   return g;
5267 }
5268
5269 /* Return whether a relocation is against a local symbol.  */
5270
5271 static boolean
5272 mips_elf_local_relocation_p (input_bfd, relocation, local_sections,
5273                              check_forced)
5274      bfd *input_bfd;
5275      const Elf_Internal_Rela *relocation;
5276      asection **local_sections;
5277      boolean check_forced;
5278 {
5279   unsigned long r_symndx;
5280   Elf_Internal_Shdr *symtab_hdr;
5281   struct mips_elf_link_hash_entry *h;
5282   size_t extsymoff;
5283
5284   r_symndx = ELF32_R_SYM (relocation->r_info);
5285   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5286   extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
5287
5288   if (r_symndx < extsymoff)
5289     return true;
5290   if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
5291     return true;
5292
5293   if (check_forced)
5294     {
5295       /* Look up the hash table to check whether the symbol
5296          was forced local.  */
5297       h = (struct mips_elf_link_hash_entry *)
5298         elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
5299       /* Find the real hash-table entry for this symbol.  */
5300       while (h->root.root.type == bfd_link_hash_indirect
5301              || h->root.root.type == bfd_link_hash_warning)
5302         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5303       if ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
5304         return true;
5305     }
5306
5307   return false;
5308 }
5309
5310 /* Sign-extend VALUE, which has the indicated number of BITS.  */
5311
5312 static bfd_vma
5313 mips_elf_sign_extend (value, bits)
5314      bfd_vma value;
5315      int bits;
5316 {
5317   if (value & ((bfd_vma) 1 << (bits - 1)))
5318     /* VALUE is negative.  */
5319     value |= ((bfd_vma) - 1) << bits;
5320
5321   return value;
5322 }
5323
5324 /* Return non-zero if the indicated VALUE has overflowed the maximum
5325    range expressable by a signed number with the indicated number of
5326    BITS.  */
5327
5328 static boolean
5329 mips_elf_overflow_p (value, bits)
5330      bfd_vma value;
5331      int bits;
5332 {
5333   bfd_signed_vma svalue = (bfd_signed_vma) value;
5334
5335   if (svalue > (1 << (bits - 1)) - 1)
5336     /* The value is too big.  */
5337     return true;
5338   else if (svalue < -(1 << (bits - 1)))
5339     /* The value is too small.  */
5340     return true;
5341
5342   /* All is well.  */
5343   return false;
5344 }
5345
5346 /* Calculate the %high function.  */
5347
5348 static bfd_vma
5349 mips_elf_high (value)
5350      bfd_vma value;
5351 {
5352   return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
5353 }
5354
5355 /* Calculate the %higher function.  */
5356
5357 static bfd_vma
5358 mips_elf_higher (value)
5359      bfd_vma value ATTRIBUTE_UNUSED;
5360 {
5361 #ifdef BFD64
5362   return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
5363 #else
5364   abort ();
5365   return (bfd_vma) -1;
5366 #endif
5367 }
5368
5369 /* Calculate the %highest function.  */
5370
5371 static bfd_vma
5372 mips_elf_highest (value)
5373      bfd_vma value ATTRIBUTE_UNUSED;
5374 {
5375 #ifdef BFD64
5376   return ((value + (bfd_vma) 0x800080008000) >> 48) & 0xffff;
5377 #else
5378   abort ();
5379   return (bfd_vma) -1;
5380 #endif
5381 }
5382
5383 /* Returns the GOT index for the global symbol indicated by H.  */
5384
5385 static bfd_vma
5386 mips_elf_global_got_index (abfd, h)
5387      bfd *abfd;
5388      struct elf_link_hash_entry *h;
5389 {
5390   bfd_vma index;
5391   asection *sgot;
5392   struct mips_got_info *g;
5393
5394   g = mips_elf_got_info (abfd, &sgot);
5395
5396   /* Once we determine the global GOT entry with the lowest dynamic
5397      symbol table index, we must put all dynamic symbols with greater
5398      indices into the GOT.  That makes it easy to calculate the GOT
5399      offset.  */
5400   BFD_ASSERT (h->dynindx >= g->global_gotsym->dynindx);
5401   index = ((h->dynindx - g->global_gotsym->dynindx + g->local_gotno)
5402            * MIPS_ELF_GOT_SIZE (abfd));
5403   BFD_ASSERT (index < sgot->_raw_size);
5404
5405   return index;
5406 }
5407
5408 /* Returns the offset for the entry at the INDEXth position
5409    in the GOT.  */
5410
5411 static bfd_vma
5412 mips_elf_got_offset_from_index (dynobj, output_bfd, index)
5413      bfd *dynobj;
5414      bfd *output_bfd;
5415      bfd_vma index;
5416 {
5417   asection *sgot;
5418   bfd_vma gp;
5419
5420   sgot = mips_elf_got_section (dynobj);
5421   gp = _bfd_get_gp_value (output_bfd);
5422   return (sgot->output_section->vma + sgot->output_offset + index -
5423           gp);
5424 }
5425
5426 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5427    symbol table index lower than any we've seen to date, record it for
5428    posterity.  */
5429
5430 static boolean
5431 mips_elf_record_global_got_symbol (h, info, g)
5432      struct elf_link_hash_entry *h;
5433      struct bfd_link_info *info;
5434      struct mips_got_info *g ATTRIBUTE_UNUSED;
5435 {
5436   /* A global symbol in the GOT must also be in the dynamic symbol
5437      table.  */
5438   if (h->dynindx == -1
5439       && !bfd_elf32_link_record_dynamic_symbol (info, h))
5440     return false;
5441
5442   /* If we've already marked this entry as need GOT space, we don't
5443      need to do it again.  */
5444   if (h->got.offset != (bfd_vma) - 1)
5445     return true;
5446
5447   /* By setting this to a value other than -1, we are indicating that
5448      there needs to be a GOT entry for H.  */
5449   h->got.offset = 0;
5450
5451   return true;
5452 }
5453
5454 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
5455    the dynamic symbols.  */
5456
5457 struct mips_elf_hash_sort_data {
5458   /* The symbol in the global GOT with the lowest dynamic symbol table
5459      index.  */
5460   struct elf_link_hash_entry *low;
5461   /* The least dynamic symbol table index corresponding to a symbol
5462      with a GOT entry.  */
5463   long min_got_dynindx;
5464   /* The greatest dynamic symbol table index not corresponding to a
5465      symbol without a GOT entry.  */
5466   long max_non_got_dynindx;
5467 };
5468
5469 /* If H needs a GOT entry, assign it the highest available dynamic
5470    index.  Otherwise, assign it the lowest available dynamic
5471    index.  */
5472
5473 static boolean
5474 mips_elf_sort_hash_table_f (h, data)
5475      struct mips_elf_link_hash_entry *h;
5476      PTR data;
5477 {
5478   struct mips_elf_hash_sort_data *hsd
5479     = (struct mips_elf_hash_sort_data *) data;
5480
5481   /* Symbols without dynamic symbol table entries aren't interesting
5482      at all.  */
5483   if (h->root.dynindx == -1)
5484     return true;
5485
5486   if (h->root.got.offset != 0)
5487     h->root.dynindx = hsd->max_non_got_dynindx++;
5488   else
5489     {
5490       h->root.dynindx = --hsd->min_got_dynindx;
5491       hsd->low = (struct elf_link_hash_entry *) h;
5492     }
5493
5494   return true;
5495 }
5496
5497 /* Sort the dynamic symbol table so that symbols that need GOT entries
5498    appear towards the end.  This reduces the amount of GOT space
5499    required.  MAX_LOCAL is used to set the number of local symbols
5500    known to be in the dynamic symbol table.  During
5501    mips_elf_size_dynamic_sections, this value is 1.  Afterward, the
5502    section symbols are added and the count is higher.  */
5503
5504 static boolean
5505 mips_elf_sort_hash_table (info, max_local)
5506      struct bfd_link_info *info;
5507      unsigned long max_local;
5508 {
5509   struct mips_elf_hash_sort_data hsd;
5510   struct mips_got_info *g;
5511   bfd *dynobj;
5512
5513   dynobj = elf_hash_table (info)->dynobj;
5514
5515   hsd.low = NULL;
5516   hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount;
5517   hsd.max_non_got_dynindx = max_local;
5518   mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
5519                                 elf_hash_table (info)),
5520                                mips_elf_sort_hash_table_f,
5521                                &hsd);
5522
5523   /* There shoud have been enough room in the symbol table to
5524      accomodate both the GOT and non-GOT symbols.  */
5525   BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
5526
5527   /* Now we know which dynamic symbol has the lowest dynamic symbol
5528      table index in the GOT.  */
5529   g = mips_elf_got_info (dynobj, NULL);
5530   g->global_gotsym = hsd.low;
5531
5532   return true;
5533 }
5534
5535 /* Create a local GOT entry for VALUE.  Return the index of the entry,
5536    or -1 if it could not be created.  */
5537
5538 static bfd_vma
5539 mips_elf_create_local_got_entry (abfd, g, sgot, value)
5540      bfd *abfd;
5541      struct mips_got_info *g;
5542      asection *sgot;
5543      bfd_vma value;
5544 {
5545   if (g->assigned_gotno >= g->local_gotno)
5546     {
5547       /* We didn't allocate enough space in the GOT.  */
5548       (*_bfd_error_handler)
5549         (_("not enough GOT space for local GOT entries"));
5550       bfd_set_error (bfd_error_bad_value);
5551       return (bfd_vma) -1;
5552     }
5553
5554   MIPS_ELF_PUT_WORD (abfd, value,
5555                      (sgot->contents
5556                       + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno));
5557   return MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
5558 }
5559
5560 /* Returns the GOT offset at which the indicated address can be found.
5561    If there is not yet a GOT entry for this value, create one.  Returns
5562    -1 if no satisfactory GOT offset can be found.  */
5563
5564 static bfd_vma
5565 mips_elf_local_got_index (abfd, info, value)
5566      bfd *abfd;
5567      struct bfd_link_info *info;
5568      bfd_vma value;
5569 {
5570   asection *sgot;
5571   struct mips_got_info *g;
5572   bfd_byte *entry;
5573
5574   g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5575
5576   /* Look to see if we already have an appropriate entry.  */
5577   for (entry = (sgot->contents
5578                 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
5579        entry != sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
5580        entry += MIPS_ELF_GOT_SIZE (abfd))
5581     {
5582       bfd_vma address = MIPS_ELF_GET_WORD (abfd, entry);
5583       if (address == value)
5584         return entry - sgot->contents;
5585     }
5586
5587   return mips_elf_create_local_got_entry (abfd, g, sgot, value);
5588 }
5589
5590 /* Find a GOT entry that is within 32KB of the VALUE.  These entries
5591    are supposed to be placed at small offsets in the GOT, i.e.,
5592    within 32KB of GP.  Return the index into the GOT for this page,
5593    and store the offset from this entry to the desired address in
5594    OFFSETP, if it is non-NULL.  */
5595
5596 static bfd_vma
5597 mips_elf_got_page (abfd, info, value, offsetp)
5598      bfd *abfd;
5599      struct bfd_link_info *info;
5600      bfd_vma value;
5601      bfd_vma *offsetp;
5602 {
5603   asection *sgot;
5604   struct mips_got_info *g;
5605   bfd_byte *entry;
5606   bfd_byte *last_entry;
5607   bfd_vma index = 0;
5608   bfd_vma address;
5609
5610   g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5611
5612   /* Look to see if we aleady have an appropriate entry.  */
5613   last_entry = sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
5614   for (entry = (sgot->contents
5615                 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
5616        entry != last_entry;
5617        entry += MIPS_ELF_GOT_SIZE (abfd))
5618     {
5619       address = MIPS_ELF_GET_WORD (abfd, entry);
5620
5621       if (!mips_elf_overflow_p (value - address, 16))
5622         {
5623           /* This entry will serve as the page pointer.  We can add a
5624              16-bit number to it to get the actual address.  */
5625           index = entry - sgot->contents;
5626           break;
5627         }
5628     }
5629
5630   /* If we didn't have an appropriate entry, we create one now.  */
5631   if (entry == last_entry)
5632     index = mips_elf_create_local_got_entry (abfd, g, sgot, value);
5633
5634   if (offsetp)
5635     {
5636       address = MIPS_ELF_GET_WORD (abfd, entry);
5637       *offsetp = value - address;
5638     }
5639
5640   return index;
5641 }
5642
5643 /* Find a GOT entry whose higher-order 16 bits are the same as those
5644    for value.  Return the index into the GOT for this entry.  */
5645
5646 static bfd_vma
5647 mips_elf_got16_entry (abfd, info, value, external)
5648      bfd *abfd;
5649      struct bfd_link_info *info;
5650      bfd_vma value;
5651      boolean external;
5652 {
5653   asection *sgot;
5654   struct mips_got_info *g;
5655   bfd_byte *entry;
5656   bfd_byte *last_entry;
5657   bfd_vma index = 0;
5658   bfd_vma address;
5659
5660   if (! external)
5661     {
5662       /* Although the ABI says that it is "the high-order 16 bits" that we
5663          want, it is really the %high value.  The complete value is
5664          calculated with a `addiu' of a LO16 relocation, just as with a
5665          HI16/LO16 pair.  */
5666       value = mips_elf_high (value) << 16;
5667     }
5668
5669   g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5670
5671   /* Look to see if we already have an appropriate entry.  */
5672   last_entry = sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
5673   for (entry = (sgot->contents
5674                 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
5675        entry != last_entry;
5676        entry += MIPS_ELF_GOT_SIZE (abfd))
5677     {
5678       address = MIPS_ELF_GET_WORD (abfd, entry);
5679       if (address == value)
5680         {
5681           /* This entry has the right high-order 16 bits, and the low-order
5682              16 bits are set to zero.  */
5683           index = entry - sgot->contents;
5684           break;
5685         }
5686     }
5687
5688   /* If we didn't have an appropriate entry, we create one now.  */
5689   if (entry == last_entry)
5690     index = mips_elf_create_local_got_entry (abfd, g, sgot, value);
5691
5692   return index;
5693 }
5694
5695 /* Returns the first relocation of type r_type found, beginning with
5696    RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
5697
5698 static const Elf_Internal_Rela *
5699 mips_elf_next_relocation (r_type, relocation, relend)
5700      unsigned int r_type;
5701      const Elf_Internal_Rela *relocation;
5702      const Elf_Internal_Rela *relend;
5703 {
5704   /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5705      immediately following.  However, for the IRIX6 ABI, the next
5706      relocation may be a composed relocation consisting of several
5707      relocations for the same address.  In that case, the R_MIPS_LO16
5708      relocation may occur as one of these.  We permit a similar
5709      extension in general, as that is useful for GCC.  */
5710   while (relocation < relend)
5711     {
5712       if (ELF32_R_TYPE (relocation->r_info) == r_type)
5713         return relocation;
5714
5715       ++relocation;
5716     }
5717
5718   /* We didn't find it.  */
5719   bfd_set_error (bfd_error_bad_value);
5720   return NULL;
5721 }
5722
5723 /* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
5724    is the original relocation, which is now being transformed into a
5725    dynamic relocation.  The ADDENDP is adjusted if necessary; the
5726    caller should store the result in place of the original addend.  */
5727
5728 static boolean
5729 mips_elf_create_dynamic_relocation (output_bfd, info, rel, h, sec,
5730                                     symbol, addendp, input_section, local_p)
5731      bfd *output_bfd;
5732      struct bfd_link_info *info;
5733      const Elf_Internal_Rela *rel;
5734      struct mips_elf_link_hash_entry *h;
5735      asection *sec;
5736      bfd_vma symbol;
5737      bfd_vma *addendp;
5738      asection *input_section;
5739      boolean local_p;
5740 {
5741   Elf_Internal_Rel outrel;
5742   boolean skip;
5743   asection *sreloc;
5744   bfd *dynobj;
5745   int r_type;
5746
5747   r_type = ELF32_R_TYPE (rel->r_info);
5748   dynobj = elf_hash_table (info)->dynobj;
5749   sreloc
5750     = bfd_get_section_by_name (dynobj,
5751                                MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd));
5752   BFD_ASSERT (sreloc != NULL);
5753   BFD_ASSERT (sreloc->contents != NULL);
5754
5755   skip = false;
5756
5757   /* We begin by assuming that the offset for the dynamic relocation
5758      is the same as for the original relocation.  We'll adjust this
5759      later to reflect the correct output offsets.  */
5760   if (elf_section_data (input_section)->stab_info == NULL)
5761     outrel.r_offset = rel->r_offset;
5762   else
5763     {
5764       /* Except that in a stab section things are more complex.
5765          Because we compress stab information, the offset given in the
5766          relocation may not be the one we want; we must let the stabs
5767          machinery tell us the offset.  */
5768       outrel.r_offset
5769         = (_bfd_stab_section_offset
5770            (output_bfd, &elf_hash_table (info)->stab_info,
5771             input_section,
5772             &elf_section_data (input_section)->stab_info,
5773             rel->r_offset));
5774       /* If we didn't need the relocation at all, this value will be
5775          -1.  */
5776       if (outrel.r_offset == (bfd_vma) -1)
5777         skip = true;
5778     }
5779
5780   /* If we've decided to skip this relocation, just output an empty
5781      record.  Note that R_MIPS_NONE == 0, so that this call to memset
5782      is a way of setting R_TYPE to R_MIPS_NONE.  */
5783   if (skip)
5784     memset (&outrel, 0, sizeof (outrel));
5785   else
5786     {
5787       long indx;
5788       bfd_vma section_offset;
5789
5790       /* We must now calculate the dynamic symbol table index to use
5791          in the relocation.  */
5792       if (h != NULL
5793           && (! info->symbolic || (h->root.elf_link_hash_flags
5794                                    & ELF_LINK_HASH_DEF_REGULAR) == 0))
5795         {
5796           indx = h->root.dynindx;
5797           /* h->root.dynindx may be -1 if this symbol was marked to
5798              become local.  */
5799           if (indx == -1)
5800             indx = 0;
5801         }
5802       else
5803         {
5804           if (sec != NULL && bfd_is_abs_section (sec))
5805             indx = 0;
5806           else if (sec == NULL || sec->owner == NULL)
5807             {
5808               bfd_set_error (bfd_error_bad_value);
5809               return false;
5810             }
5811           else
5812             {
5813               indx = elf_section_data (sec->output_section)->dynindx;
5814               if (indx == 0)
5815                 abort ();
5816             }
5817
5818           /* Figure out how far the target of the relocation is from
5819              the beginning of its section.  */
5820           section_offset = symbol - sec->output_section->vma;
5821           /* The relocation we're building is section-relative.
5822              Therefore, the original addend must be adjusted by the
5823              section offset.  */
5824           *addendp += symbol - sec->output_section->vma;
5825           /* Now, the relocation is just against the section.  */
5826           symbol = sec->output_section->vma;
5827         }
5828
5829       /* If the relocation is against a local symbol was previously an
5830          absolute relocation, we must adjust it by the value we give
5831          it in the dynamic symbol table.  */
5832       if (local_p && r_type != R_MIPS_REL32)
5833         *addendp += symbol;
5834
5835       /* The relocation is always an REL32 relocation because we don't
5836          know where the shared library will wind up at load-time.  */
5837       outrel.r_info = ELF32_R_INFO (indx, R_MIPS_REL32);
5838
5839       /* Adjust the output offset of the relocation to reference the
5840          correct location in the output file.  */
5841       outrel.r_offset += (input_section->output_section->vma
5842                           + input_section->output_offset);
5843     }
5844
5845   /* Put the relocation back out.  We have to use the special
5846      relocation outputter in the 64-bit case since the 64-bit
5847      relocation format is non-standard.  */
5848   if (ABI_64_P (output_bfd))
5849     {
5850       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
5851         (output_bfd, &outrel,
5852          (sreloc->contents
5853           + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
5854     }
5855   else
5856     bfd_elf32_swap_reloc_out (output_bfd, &outrel,
5857                               (((Elf32_External_Rel *)
5858                                 sreloc->contents)
5859                                + sreloc->reloc_count));
5860
5861   /* Record the index of the first relocation referencing H.  This
5862      information is later emitted in the .msym section.  */
5863   if (h != NULL
5864       && (h->min_dyn_reloc_index == 0
5865           || sreloc->reloc_count < h->min_dyn_reloc_index))
5866     h->min_dyn_reloc_index = sreloc->reloc_count;
5867
5868   /* We've now added another relocation.  */
5869   ++sreloc->reloc_count;
5870
5871   /* Make sure the output section is writable.  The dynamic linker
5872      will be writing to it.  */
5873   elf_section_data (input_section->output_section)->this_hdr.sh_flags
5874     |= SHF_WRITE;
5875
5876   /* On IRIX5, make an entry of compact relocation info.  */
5877   if (! skip && IRIX_COMPAT (output_bfd) == ict_irix5)
5878     {
5879       asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
5880       bfd_byte *cr;
5881
5882       if (scpt)
5883         {
5884           Elf32_crinfo cptrel;
5885
5886           mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
5887           cptrel.vaddr = (rel->r_offset
5888                           + input_section->output_section->vma
5889                           + input_section->output_offset);
5890           if (r_type == R_MIPS_REL32)
5891             mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
5892           else
5893             mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
5894           mips_elf_set_cr_dist2to (cptrel, 0);
5895           cptrel.konst = *addendp;
5896
5897           cr = (scpt->contents
5898                 + sizeof (Elf32_External_compact_rel));
5899           bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
5900                                      ((Elf32_External_crinfo *) cr
5901                                       + scpt->reloc_count));
5902           ++scpt->reloc_count;
5903         }
5904     }
5905
5906   return true;
5907 }
5908
5909 /* Calculate the value produced by the RELOCATION (which comes from
5910    the INPUT_BFD).  The ADDEND is the addend to use for this
5911    RELOCATION; RELOCATION->R_ADDEND is ignored.
5912
5913    The result of the relocation calculation is stored in VALUEP.
5914    REQUIRE_JALXP indicates whether or not the opcode used with this
5915    relocation must be JALX.
5916
5917    This function returns bfd_reloc_continue if the caller need take no
5918    further action regarding this relocation, bfd_reloc_notsupported if
5919    something goes dramatically wrong, bfd_reloc_overflow if an
5920    overflow occurs, and bfd_reloc_ok to indicate success.  */
5921
5922 static bfd_reloc_status_type
5923 mips_elf_calculate_relocation (abfd,
5924                                input_bfd,
5925                                input_section,
5926                                info,
5927                                relocation,
5928                                addend,
5929                                howto,
5930                                local_syms,
5931                                local_sections,
5932                                valuep,
5933                                namep,
5934                                require_jalxp)
5935      bfd *abfd;
5936      bfd *input_bfd;
5937      asection *input_section;
5938      struct bfd_link_info *info;
5939      const Elf_Internal_Rela *relocation;
5940      bfd_vma addend;
5941      reloc_howto_type *howto;
5942      Elf_Internal_Sym *local_syms;
5943      asection **local_sections;
5944      bfd_vma *valuep;
5945      const char **namep;
5946      boolean *require_jalxp;
5947 {
5948   /* The eventual value we will return.  */
5949   bfd_vma value;
5950   /* The address of the symbol against which the relocation is
5951      occurring.  */
5952   bfd_vma symbol = 0;
5953   /* The final GP value to be used for the relocatable, executable, or
5954      shared object file being produced.  */
5955   bfd_vma gp = (bfd_vma) - 1;
5956   /* The place (section offset or address) of the storage unit being
5957      relocated.  */
5958   bfd_vma p;
5959   /* The value of GP used to create the relocatable object.  */
5960   bfd_vma gp0 = (bfd_vma) - 1;
5961   /* The offset into the global offset table at which the address of
5962      the relocation entry symbol, adjusted by the addend, resides
5963      during execution.  */
5964   bfd_vma g = (bfd_vma) - 1;
5965   /* The section in which the symbol referenced by the relocation is
5966      located.  */
5967   asection *sec = NULL;
5968   struct mips_elf_link_hash_entry *h = NULL;
5969   /* True if the symbol referred to by this relocation is a local
5970      symbol.  */
5971   boolean local_p;
5972   /* True if the symbol referred to by this relocation is "_gp_disp".  */
5973   boolean gp_disp_p = false;
5974   Elf_Internal_Shdr *symtab_hdr;
5975   size_t extsymoff;
5976   unsigned long r_symndx;
5977   int r_type;
5978   /* True if overflow occurred during the calculation of the
5979      relocation value.  */
5980   boolean overflowed_p;
5981   /* True if this relocation refers to a MIPS16 function.  */
5982   boolean target_is_16_bit_code_p = false;
5983
5984   /* Parse the relocation.  */
5985   r_symndx = ELF32_R_SYM (relocation->r_info);
5986   r_type = ELF32_R_TYPE (relocation->r_info);
5987   p = (input_section->output_section->vma
5988        + input_section->output_offset
5989        + relocation->r_offset);
5990
5991   /* Assume that there will be no overflow.  */
5992   overflowed_p = false;
5993
5994   /* Figure out whether or not the symbol is local, and get the offset
5995      used in the array of hash table entries.  */
5996   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5997   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5998                                          local_sections, false);
5999   if (! elf_bad_symtab (input_bfd))
6000     extsymoff = symtab_hdr->sh_info;
6001   else
6002     {
6003       /* The symbol table does not follow the rule that local symbols
6004          must come before globals.  */
6005       extsymoff = 0;
6006     }
6007
6008   /* Figure out the value of the symbol.  */
6009   if (local_p)
6010     {
6011       Elf_Internal_Sym *sym;
6012
6013       sym = local_syms + r_symndx;
6014       sec = local_sections[r_symndx];
6015
6016       symbol = sec->output_section->vma + sec->output_offset;
6017       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
6018         symbol += sym->st_value;
6019
6020       /* MIPS16 text labels should be treated as odd.  */
6021       if (sym->st_other == STO_MIPS16)
6022         ++symbol;
6023
6024       /* Record the name of this symbol, for our caller.  */
6025       *namep = bfd_elf_string_from_elf_section (input_bfd,
6026                                                 symtab_hdr->sh_link,
6027                                                 sym->st_name);
6028       if (*namep == '\0')
6029         *namep = bfd_section_name (input_bfd, sec);
6030
6031       target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
6032     }
6033   else
6034     {
6035       /* For global symbols we look up the symbol in the hash-table.  */
6036       h = ((struct mips_elf_link_hash_entry *)
6037            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
6038       /* Find the real hash-table entry for this symbol.  */
6039       while (h->root.root.type == bfd_link_hash_indirect
6040              || h->root.root.type == bfd_link_hash_warning)
6041         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
6042
6043       /* Record the name of this symbol, for our caller.  */
6044       *namep = h->root.root.root.string;
6045
6046       /* See if this is the special _gp_disp symbol.  Note that such a
6047          symbol must always be a global symbol.  */
6048       if (strcmp (h->root.root.root.string, "_gp_disp") == 0)
6049         {
6050           /* Relocations against _gp_disp are permitted only with
6051              R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
6052           if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16)
6053             return bfd_reloc_notsupported;
6054
6055           gp_disp_p = true;
6056         }
6057       /* If this symbol is defined, calculate its address.  Note that
6058          _gp_disp is a magic symbol, always implicitly defined by the
6059          linker, so it's inappropriate to check to see whether or not
6060          its defined.  */
6061       else if ((h->root.root.type == bfd_link_hash_defined
6062                 || h->root.root.type == bfd_link_hash_defweak)
6063                && h->root.root.u.def.section)
6064         {
6065           sec = h->root.root.u.def.section;
6066           if (sec->output_section)
6067             symbol = (h->root.root.u.def.value
6068                       + sec->output_section->vma
6069                       + sec->output_offset);
6070           else
6071             symbol = h->root.root.u.def.value;
6072         }
6073       else if (h->root.root.type == bfd_link_hash_undefweak)
6074         /* We allow relocations against undefined weak symbols, giving
6075            it the value zero, so that you can undefined weak functions
6076            and check to see if they exist by looking at their
6077            addresses.  */
6078         symbol = 0;
6079       else if (info->shared && !info->symbolic && !info->no_undefined
6080                && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
6081         symbol = 0;
6082       else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0 ||
6083               strcmp (h->root.root.root.string, "_DYNAMIC_LINKING") == 0)
6084         {
6085           /* If this is a dynamic link, we should have created a
6086              _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
6087              in in mips_elf_create_dynamic_sections.
6088              Otherwise, we should define the symbol with a value of 0.
6089              FIXME: It should probably get into the symbol table
6090              somehow as well.  */
6091           BFD_ASSERT (! info->shared);
6092           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
6093           symbol = 0;
6094         }
6095       else
6096         {
6097           if (! ((*info->callbacks->undefined_symbol)
6098                  (info, h->root.root.root.string, input_bfd,
6099                   input_section, relocation->r_offset,
6100                   (!info->shared || info->no_undefined
6101                    || ELF_ST_VISIBILITY (h->root.other)))))
6102             return bfd_reloc_undefined;
6103           symbol = 0;
6104         }
6105
6106       target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
6107     }
6108
6109   /* If this is a 32-bit call to a 16-bit function with a stub, we
6110      need to redirect the call to the stub, unless we're already *in*
6111      a stub.  */
6112   if (r_type != R_MIPS16_26 && !info->relocateable
6113       && ((h != NULL && h->fn_stub != NULL)
6114           || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
6115               && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
6116       && !mips_elf_stub_section_p (input_bfd, input_section))
6117     {
6118       /* This is a 32-bit call to a 16-bit function.  We should
6119          have already noticed that we were going to need the
6120          stub.  */
6121       if (local_p)
6122         sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
6123       else
6124         {
6125           BFD_ASSERT (h->need_fn_stub);
6126           sec = h->fn_stub;
6127         }
6128
6129       symbol = sec->output_section->vma + sec->output_offset;
6130     }
6131   /* If this is a 16-bit call to a 32-bit function with a stub, we
6132      need to redirect the call to the stub.  */
6133   else if (r_type == R_MIPS16_26 && !info->relocateable
6134            && h != NULL
6135            && (h->call_stub != NULL || h->call_fp_stub != NULL)
6136            && !target_is_16_bit_code_p)
6137     {
6138       /* If both call_stub and call_fp_stub are defined, we can figure
6139          out which one to use by seeing which one appears in the input
6140          file.  */
6141       if (h->call_stub != NULL && h->call_fp_stub != NULL)
6142         {
6143           asection *o;
6144
6145           sec = NULL;
6146           for (o = input_bfd->sections; o != NULL; o = o->next)
6147             {
6148               if (strncmp (bfd_get_section_name (input_bfd, o),
6149                            CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
6150                 {
6151                   sec = h->call_fp_stub;
6152                   break;
6153                 }
6154             }
6155           if (sec == NULL)
6156             sec = h->call_stub;
6157         }
6158       else if (h->call_stub != NULL)
6159         sec = h->call_stub;
6160       else
6161         sec = h->call_fp_stub;
6162
6163       BFD_ASSERT (sec->_raw_size > 0);
6164       symbol = sec->output_section->vma + sec->output_offset;
6165     }
6166
6167   /* Calls from 16-bit code to 32-bit code and vice versa require the
6168      special jalx instruction.  */
6169   *require_jalxp = (!info->relocateable
6170                     && ((r_type == R_MIPS16_26) != target_is_16_bit_code_p));
6171
6172   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
6173                                          local_sections, true);
6174
6175   /* If we haven't already determined the GOT offset, or the GP value,
6176      and we're going to need it, get it now.  */
6177   switch (r_type)
6178     {
6179     case R_MIPS_CALL16:
6180     case R_MIPS_GOT16:
6181     case R_MIPS_GOT_DISP:
6182     case R_MIPS_GOT_HI16:
6183     case R_MIPS_CALL_HI16:
6184     case R_MIPS_GOT_LO16:
6185     case R_MIPS_CALL_LO16:
6186       /* Find the index into the GOT where this value is located.  */
6187       if (!local_p)
6188         {
6189           BFD_ASSERT (addend == 0);
6190           g = mips_elf_global_got_index
6191             (elf_hash_table (info)->dynobj,
6192              (struct elf_link_hash_entry *) h);
6193           if (! elf_hash_table(info)->dynamic_sections_created
6194               || (info->shared
6195                   && (info->symbolic || h->root.dynindx == -1)
6196                   && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
6197             {
6198               /* This is a static link or a -Bsymbolic link.  The
6199                  symbol is defined locally, or was forced to be local.
6200                  We must initialize this entry in the GOT.  */
6201               asection *sgot = mips_elf_got_section(elf_hash_table
6202                                                     (info)->dynobj);
6203               MIPS_ELF_PUT_WORD (elf_hash_table (info)->dynobj,
6204                                  symbol + addend, sgot->contents + g);
6205             }
6206         }
6207       else if (r_type == R_MIPS_GOT16)
6208         /* There's no need to create a local GOT entry here; the
6209            calculation for a local GOT16 entry does not involve G.  */
6210         break;
6211       else
6212         {
6213           g = mips_elf_local_got_index (abfd, info, symbol + addend);
6214           if (g == (bfd_vma) -1)
6215             return false;
6216         }
6217
6218       /* Convert GOT indices to actual offsets.  */
6219       g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6220                                           abfd, g);
6221       break;
6222
6223     case R_MIPS_HI16:
6224     case R_MIPS_LO16:
6225     case R_MIPS_GPREL16:
6226     case R_MIPS_GPREL32:
6227     case R_MIPS_LITERAL:
6228       gp0 = _bfd_get_gp_value (input_bfd);
6229       gp = _bfd_get_gp_value (abfd);
6230       break;
6231
6232     default:
6233       break;
6234     }
6235
6236   /* Figure out what kind of relocation is being performed.  */
6237   switch (r_type)
6238     {
6239     case R_MIPS_NONE:
6240       return bfd_reloc_continue;
6241
6242     case R_MIPS_16:
6243       value = symbol + mips_elf_sign_extend (addend, 16);
6244       overflowed_p = mips_elf_overflow_p (value, 16);
6245       break;
6246
6247     case R_MIPS_32:
6248     case R_MIPS_REL32:
6249     case R_MIPS_64:
6250       if ((info->shared
6251            || (elf_hash_table (info)->dynamic_sections_created
6252                && h != NULL
6253                && ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
6254                    != 0)))
6255           && (input_section->flags & SEC_ALLOC) != 0)
6256         {
6257           /* If we're creating a shared library, or this relocation is
6258              against a symbol in a shared library, then we can't know
6259              where the symbol will end up.  So, we create a relocation
6260              record in the output, and leave the job up to the dynamic
6261              linker.  */
6262           value = addend;
6263           if (!mips_elf_create_dynamic_relocation (abfd,
6264                                                    info,
6265                                                    relocation,
6266                                                    h,
6267                                                    sec,
6268                                                    symbol,
6269                                                    &value,
6270                                                    input_section, local_p))
6271             return false;
6272         }
6273       else
6274         {
6275           if (r_type != R_MIPS_REL32)
6276             value = symbol + addend;
6277           else
6278             value = addend;
6279         }
6280       value &= howto->dst_mask;
6281       break;
6282
6283     case R_MIPS_PC32:
6284     case R_MIPS_PC64:
6285     case R_MIPS_GNU_REL_LO16:
6286       value = symbol + addend - p;
6287       value &= howto->dst_mask;
6288       break;
6289
6290     case R_MIPS_GNU_REL16_S2:
6291       value = symbol + mips_elf_sign_extend (addend << 2, 18) - p;
6292       overflowed_p = mips_elf_overflow_p (value, 18);
6293       value = (value >> 2) & howto->dst_mask;
6294       break;
6295
6296     case R_MIPS_GNU_REL_HI16:
6297       value = mips_elf_high (addend + symbol - p);
6298       value &= howto->dst_mask;
6299       break;
6300
6301     case R_MIPS16_26:
6302       /* The calculation for R_MIPS_26 is just the same as for an
6303          R_MIPS_26.  It's only the storage of the relocated field into
6304          the output file that's different.  That's handled in
6305          mips_elf_perform_relocation.  So, we just fall through to the
6306          R_MIPS_26 case here.  */
6307     case R_MIPS_26:
6308       if (local_p)
6309         value = (((addend << 2) | (p & 0xf0000000)) + symbol) >> 2;
6310       else
6311         value = (mips_elf_sign_extend (addend << 2, 28) + symbol) >> 2;
6312       value &= howto->dst_mask;
6313       break;
6314
6315     case R_MIPS_HI16:
6316       if (!gp_disp_p)
6317         {
6318           value = mips_elf_high (addend + symbol);
6319           value &= howto->dst_mask;
6320         }
6321       else
6322         {
6323           value = mips_elf_high (addend + gp - p);
6324           overflowed_p = mips_elf_overflow_p (value, 16);
6325         }
6326       break;
6327
6328     case R_MIPS_LO16:
6329       if (!gp_disp_p)
6330         value = (symbol + addend) & howto->dst_mask;
6331       else
6332         {
6333           value = addend + gp - p + 4;
6334           /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6335              for overflow.  But, on, say, Irix 5, relocations against
6336              _gp_disp are normally generated from the .cpload
6337              pseudo-op.  It generates code that normally looks like
6338              this:
6339
6340                lui    $gp,%hi(_gp_disp)
6341                addiu  $gp,$gp,%lo(_gp_disp)
6342                addu   $gp,$gp,$t9
6343
6344              Here $t9 holds the address of the function being called,
6345              as required by the MIPS ELF ABI.  The R_MIPS_LO16
6346              relocation can easily overflow in this situation, but the
6347              R_MIPS_HI16 relocation will handle the overflow.
6348              Therefore, we consider this a bug in the MIPS ABI, and do
6349              not check for overflow here.  */
6350         }
6351       break;
6352
6353     case R_MIPS_LITERAL:
6354       /* Because we don't merge literal sections, we can handle this
6355          just like R_MIPS_GPREL16.  In the long run, we should merge
6356          shared literals, and then we will need to additional work
6357          here.  */
6358
6359       /* Fall through.  */
6360
6361     case R_MIPS16_GPREL:
6362       /* The R_MIPS16_GPREL performs the same calculation as
6363          R_MIPS_GPREL16, but stores the relocated bits in a different
6364          order.  We don't need to do anything special here; the
6365          differences are handled in mips_elf_perform_relocation.  */
6366     case R_MIPS_GPREL16:
6367       if (local_p)
6368         value = mips_elf_sign_extend (addend, 16) + symbol + gp0 - gp;
6369       else
6370         value = mips_elf_sign_extend (addend, 16) + symbol - gp;
6371       overflowed_p = mips_elf_overflow_p (value, 16);
6372       break;
6373
6374     case R_MIPS_GOT16:
6375       if (local_p)
6376         {
6377           boolean forced;
6378
6379           /* The special case is when the symbol is forced to be local.  We
6380              need the full address in the GOT since no R_MIPS_LO16 relocation
6381              follows.  */
6382           forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
6383                                                   local_sections, false);
6384           value = mips_elf_got16_entry (abfd, info, symbol + addend, forced);
6385           if (value == (bfd_vma) -1)
6386             return false;
6387           value
6388             = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6389                                               abfd,
6390                                               value);
6391           overflowed_p = mips_elf_overflow_p (value, 16);
6392           break;
6393         }
6394
6395       /* Fall through.  */
6396
6397     case R_MIPS_CALL16:
6398     case R_MIPS_GOT_DISP:
6399       value = g;
6400       overflowed_p = mips_elf_overflow_p (value, 16);
6401       break;
6402
6403     case R_MIPS_GPREL32:
6404       value = (addend + symbol + gp0 - gp) & howto->dst_mask;
6405       break;
6406
6407     case R_MIPS_PC16:
6408       value = mips_elf_sign_extend (addend, 16) + symbol - p;
6409       value = (bfd_vma) ((bfd_signed_vma) value / 4);
6410       overflowed_p = mips_elf_overflow_p (value, 16);
6411       break;
6412
6413     case R_MIPS_GOT_HI16:
6414     case R_MIPS_CALL_HI16:
6415       /* We're allowed to handle these two relocations identically.
6416          The dynamic linker is allowed to handle the CALL relocations
6417          differently by creating a lazy evaluation stub.  */
6418       value = g;
6419       value = mips_elf_high (value);
6420       value &= howto->dst_mask;
6421       break;
6422
6423     case R_MIPS_GOT_LO16:
6424     case R_MIPS_CALL_LO16:
6425       value = g & howto->dst_mask;
6426       break;
6427
6428     case R_MIPS_GOT_PAGE:
6429       value = mips_elf_got_page (abfd, info, symbol + addend, NULL);
6430       if (value == (bfd_vma) -1)
6431         return false;
6432       value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6433                                               abfd,
6434                                               value);
6435       overflowed_p = mips_elf_overflow_p (value, 16);
6436       break;
6437
6438     case R_MIPS_GOT_OFST:
6439       mips_elf_got_page (abfd, info, symbol + addend, &value);
6440       overflowed_p = mips_elf_overflow_p (value, 16);
6441       break;
6442
6443     case R_MIPS_SUB:
6444       value = symbol - addend;
6445       value &= howto->dst_mask;
6446       break;
6447
6448     case R_MIPS_HIGHER:
6449       value = mips_elf_higher (addend + symbol);
6450       value &= howto->dst_mask;
6451       break;
6452
6453     case R_MIPS_HIGHEST:
6454       value = mips_elf_highest (addend + symbol);
6455       value &= howto->dst_mask;
6456       break;
6457
6458     case R_MIPS_SCN_DISP:
6459       value = symbol + addend - sec->output_offset;
6460       value &= howto->dst_mask;
6461       break;
6462
6463     case R_MIPS_PJUMP:
6464     case R_MIPS_JALR:
6465       /* Both of these may be ignored.  R_MIPS_JALR is an optimization
6466          hint; we could improve performance by honoring that hint.  */
6467       return bfd_reloc_continue;
6468
6469     case R_MIPS_GNU_VTINHERIT:
6470     case R_MIPS_GNU_VTENTRY:
6471       /* We don't do anything with these at present.  */
6472       return bfd_reloc_continue;
6473
6474     default:
6475       /* An unrecognized relocation type.  */
6476       return bfd_reloc_notsupported;
6477     }
6478
6479   /* Store the VALUE for our caller.  */
6480   *valuep = value;
6481   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6482 }
6483
6484 /* Obtain the field relocated by RELOCATION.  */
6485
6486 static bfd_vma
6487 mips_elf_obtain_contents (howto, relocation, input_bfd, contents)
6488      reloc_howto_type *howto;
6489      const Elf_Internal_Rela *relocation;
6490      bfd *input_bfd;
6491      bfd_byte *contents;
6492 {
6493   bfd_vma x;
6494   bfd_byte *location = contents + relocation->r_offset;
6495
6496   /* Obtain the bytes.  */
6497   x = bfd_get (8 * bfd_get_reloc_size (howto), input_bfd, location);
6498
6499   if ((ELF32_R_TYPE (relocation->r_info) == R_MIPS16_26
6500        || ELF32_R_TYPE (relocation->r_info) == R_MIPS16_GPREL)
6501       && bfd_little_endian (input_bfd))
6502     /* The two 16-bit words will be reversed on a little-endian
6503        system.  See mips_elf_perform_relocation for more details.  */
6504     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6505
6506   return x;
6507 }
6508
6509 /* It has been determined that the result of the RELOCATION is the
6510    VALUE.  Use HOWTO to place VALUE into the output file at the
6511    appropriate position.  The SECTION is the section to which the
6512    relocation applies.  If REQUIRE_JALX is true, then the opcode used
6513    for the relocation must be either JAL or JALX, and it is
6514    unconditionally converted to JALX.
6515
6516    Returns false if anything goes wrong.  */
6517
6518 static boolean
6519 mips_elf_perform_relocation (info, howto, relocation, value,
6520                              input_bfd, input_section,
6521                              contents, require_jalx)
6522      struct bfd_link_info *info;
6523      reloc_howto_type *howto;
6524      const Elf_Internal_Rela *relocation;
6525      bfd_vma value;
6526      bfd *input_bfd;
6527      asection *input_section;
6528      bfd_byte *contents;
6529      boolean require_jalx;
6530 {
6531   bfd_vma x;
6532   bfd_byte *location;
6533   int r_type = ELF32_R_TYPE (relocation->r_info);
6534
6535   /* Figure out where the relocation is occurring.  */
6536   location = contents + relocation->r_offset;
6537
6538   /* Obtain the current value.  */
6539   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
6540
6541   /* Clear the field we are setting.  */
6542   x &= ~howto->dst_mask;
6543
6544   /* If this is the R_MIPS16_26 relocation, we must store the
6545      value in a funny way.  */
6546   if (r_type == R_MIPS16_26)
6547     {
6548       /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6549          Most mips16 instructions are 16 bits, but these instructions
6550          are 32 bits.
6551
6552          The format of these instructions is:
6553
6554          +--------------+--------------------------------+
6555          !     JALX     ! X!   Imm 20:16  !   Imm 25:21  !
6556          +--------------+--------------------------------+
6557          !                Immediate  15:0                   !
6558          +-----------------------------------------------+
6559
6560          JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
6561          Note that the immediate value in the first word is swapped.
6562
6563          When producing a relocateable object file, R_MIPS16_26 is
6564          handled mostly like R_MIPS_26.  In particular, the addend is
6565          stored as a straight 26-bit value in a 32-bit instruction.
6566          (gas makes life simpler for itself by never adjusting a
6567          R_MIPS16_26 reloc to be against a section, so the addend is
6568          always zero).  However, the 32 bit instruction is stored as 2
6569          16-bit values, rather than a single 32-bit value.  In a
6570          big-endian file, the result is the same; in a little-endian
6571          file, the two 16-bit halves of the 32 bit value are swapped.
6572          This is so that a disassembler can recognize the jal
6573          instruction.
6574
6575          When doing a final link, R_MIPS16_26 is treated as a 32 bit
6576          instruction stored as two 16-bit values.  The addend A is the
6577          contents of the targ26 field.  The calculation is the same as
6578          R_MIPS_26.  When storing the calculated value, reorder the
6579          immediate value as shown above, and don't forget to store the
6580          value as two 16-bit values.
6581
6582          To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6583          defined as
6584
6585          big-endian:
6586          +--------+----------------------+
6587          |        |                      |
6588          |        |    targ26-16         |
6589          |31    26|25                   0|
6590          +--------+----------------------+
6591
6592          little-endian:
6593          +----------+------+-------------+
6594          |          |      |             |
6595          |  sub1    |      |     sub2    |
6596          |0        9|10  15|16         31|
6597          +----------+--------------------+
6598          where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6599          ((sub1 << 16) | sub2)).
6600
6601          When producing a relocateable object file, the calculation is
6602          (((A < 2) | (P & 0xf0000000) + S) >> 2)
6603          When producing a fully linked file, the calculation is
6604          let R = (((A < 2) | (P & 0xf0000000) + S) >> 2)
6605          ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)  */
6606
6607       if (!info->relocateable)
6608         /* Shuffle the bits according to the formula above.  */
6609         value = (((value & 0x1f0000) << 5)
6610                  | ((value & 0x3e00000) >> 5)
6611                  | (value & 0xffff));
6612
6613     }
6614   else if (r_type == R_MIPS16_GPREL)
6615     {
6616       /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6617          mode.  A typical instruction will have a format like this:
6618
6619          +--------------+--------------------------------+
6620          !    EXTEND    !     Imm 10:5    !   Imm 15:11  !
6621          +--------------+--------------------------------+
6622          !    Major     !   rx   !   ry   !   Imm  4:0   !
6623          +--------------+--------------------------------+
6624
6625          EXTEND is the five bit value 11110.  Major is the instruction
6626          opcode.
6627
6628          This is handled exactly like R_MIPS_GPREL16, except that the
6629          addend is retrieved and stored as shown in this diagram; that
6630          is, the Imm fields above replace the V-rel16 field.
6631
6632          All we need to do here is shuffle the bits appropriately.  As
6633          above, the two 16-bit halves must be swapped on a
6634          little-endian system.  */
6635       value = (((value & 0x7e0) << 16)
6636                | ((value & 0xf800) << 5)
6637                | (value & 0x1f));
6638     }
6639
6640   /* Set the field.  */
6641   x |= (value & howto->dst_mask);
6642
6643   /* If required, turn JAL into JALX.  */
6644   if (require_jalx)
6645     {
6646       boolean ok;
6647       bfd_vma opcode = x >> 26;
6648       bfd_vma jalx_opcode;
6649
6650       /* Check to see if the opcode is already JAL or JALX.  */
6651       if (r_type == R_MIPS16_26)
6652         {
6653           ok = ((opcode == 0x6) || (opcode == 0x7));
6654           jalx_opcode = 0x7;
6655         }
6656       else
6657         {
6658           ok = ((opcode == 0x3) || (opcode == 0x1d));
6659           jalx_opcode = 0x1d;
6660         }
6661
6662       /* If the opcode is not JAL or JALX, there's a problem.  */
6663       if (!ok)
6664         {
6665           (*_bfd_error_handler)
6666             (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6667              bfd_get_filename (input_bfd),
6668              input_section->name,
6669              (unsigned long) relocation->r_offset);
6670           bfd_set_error (bfd_error_bad_value);
6671           return false;
6672         }
6673
6674       /* Make this the JALX opcode.  */
6675       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6676     }
6677
6678   /* Swap the high- and low-order 16 bits on little-endian systems
6679      when doing a MIPS16 relocation.  */
6680   if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
6681       && bfd_little_endian (input_bfd))
6682     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6683
6684   /* Put the value into the output.  */
6685   bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
6686   return true;
6687 }
6688
6689 /* Returns true if SECTION is a MIPS16 stub section.  */
6690
6691 static boolean
6692 mips_elf_stub_section_p (abfd, section)
6693      bfd *abfd ATTRIBUTE_UNUSED;
6694      asection *section;
6695 {
6696   const char *name = bfd_get_section_name (abfd, section);
6697
6698   return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
6699           || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
6700           || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
6701 }
6702
6703 /* Relocate a MIPS ELF section.  */
6704
6705 boolean
6706 _bfd_mips_elf_relocate_section (output_bfd, info, input_bfd, input_section,
6707                                 contents, relocs, local_syms, local_sections)
6708      bfd *output_bfd;
6709      struct bfd_link_info *info;
6710      bfd *input_bfd;
6711      asection *input_section;
6712      bfd_byte *contents;
6713      Elf_Internal_Rela *relocs;
6714      Elf_Internal_Sym *local_syms;
6715      asection **local_sections;
6716 {
6717   Elf_Internal_Rela *rel;
6718   const Elf_Internal_Rela *relend;
6719   bfd_vma addend = 0;
6720   boolean use_saved_addend_p = false;
6721   struct elf_backend_data *bed;
6722
6723   bed = get_elf_backend_data (output_bfd);
6724   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6725   for (rel = relocs; rel < relend; ++rel)
6726     {
6727       const char *name;
6728       bfd_vma value;
6729       reloc_howto_type *howto;
6730       boolean require_jalx;
6731       /* True if the relocation is a RELA relocation, rather than a
6732          REL relocation.  */
6733       boolean rela_relocation_p = true;
6734       int r_type = ELF32_R_TYPE (rel->r_info);
6735
6736       /* Find the relocation howto for this relocation.  */
6737       if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
6738         {
6739           /* Some 32-bit code uses R_MIPS_64.  In particular, people use
6740              64-bit code, but make sure all their addresses are in the
6741              lowermost or uppermost 32-bit section of the 64-bit address
6742              space.  Thus, when they use an R_MIPS_64 they mean what is
6743              usually meant by R_MIPS_32, with the exception that the
6744              stored value is sign-extended to 64 bits.  */
6745           howto = elf_mips_howto_table + R_MIPS_32;
6746
6747           /* On big-endian systems, we need to lie about the position
6748              of the reloc.  */
6749           if (bfd_big_endian (input_bfd))
6750             rel->r_offset += 4;
6751         }
6752       else
6753         howto = mips_rtype_to_howto (r_type);
6754
6755       if (!use_saved_addend_p)
6756         {
6757           Elf_Internal_Shdr *rel_hdr;
6758
6759           /* If these relocations were originally of the REL variety,
6760              we must pull the addend out of the field that will be
6761              relocated.  Otherwise, we simply use the contents of the
6762              RELA relocation.  To determine which flavor or relocation
6763              this is, we depend on the fact that the INPUT_SECTION's
6764              REL_HDR is read before its REL_HDR2.  */
6765           rel_hdr = &elf_section_data (input_section)->rel_hdr;
6766           if ((size_t) (rel - relocs)
6767               >= (rel_hdr->sh_size / rel_hdr->sh_entsize
6768                   * bed->s->int_rels_per_ext_rel))
6769             rel_hdr = elf_section_data (input_section)->rel_hdr2;
6770           if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6771             {
6772               /* Note that this is a REL relocation.  */
6773               rela_relocation_p = false;
6774
6775               /* Get the addend, which is stored in the input file.  */
6776               addend = mips_elf_obtain_contents (howto,
6777                                                  rel,
6778                                                  input_bfd,
6779                                                  contents);
6780               addend &= howto->src_mask;
6781
6782               /* For some kinds of relocations, the ADDEND is a
6783                  combination of the addend stored in two different
6784                  relocations.   */
6785               if (r_type == R_MIPS_HI16
6786                   || r_type == R_MIPS_GNU_REL_HI16
6787                   || (r_type == R_MIPS_GOT16
6788                       && mips_elf_local_relocation_p (input_bfd, rel,
6789                                                       local_sections, false)))
6790                 {
6791                   bfd_vma l;
6792                   const Elf_Internal_Rela *lo16_relocation;
6793                   reloc_howto_type *lo16_howto;
6794                   int lo;
6795
6796                   /* The combined value is the sum of the HI16 addend,
6797                      left-shifted by sixteen bits, and the LO16
6798                      addend, sign extended.  (Usually, the code does
6799                      a `lui' of the HI16 value, and then an `addiu' of
6800                      the LO16 value.)
6801
6802                      Scan ahead to find a matching LO16 relocation.  */
6803                   if (r_type == R_MIPS_GNU_REL_HI16)
6804                     lo = R_MIPS_GNU_REL_LO16;
6805                   else
6806                     lo = R_MIPS_LO16;
6807                   lo16_relocation
6808                     = mips_elf_next_relocation (lo, rel, relend);
6809                   if (lo16_relocation == NULL)
6810                     return false;
6811
6812                   /* Obtain the addend kept there.  */
6813                   lo16_howto = mips_rtype_to_howto (lo);
6814                   l = mips_elf_obtain_contents (lo16_howto,
6815                                                 lo16_relocation,
6816                                                 input_bfd, contents);
6817                   l &= lo16_howto->src_mask;
6818                   l = mips_elf_sign_extend (l, 16);
6819
6820                   addend <<= 16;
6821
6822                   /* Compute the combined addend.  */
6823                   addend += l;
6824                 }
6825               else if (r_type == R_MIPS16_GPREL)
6826                 {
6827                   /* The addend is scrambled in the object file.  See
6828                      mips_elf_perform_relocation for details on the
6829                      format.  */
6830                   addend = (((addend & 0x1f0000) >> 5)
6831                             | ((addend & 0x7e00000) >> 16)
6832                             | (addend & 0x1f));
6833                 }
6834             }
6835           else
6836             addend = rel->r_addend;
6837         }
6838
6839       if (info->relocateable)
6840         {
6841           Elf_Internal_Sym *sym;
6842           unsigned long r_symndx;
6843
6844           if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd)
6845               && bfd_big_endian (input_bfd))
6846             rel->r_offset -= 4;
6847
6848           /* Since we're just relocating, all we need to do is copy
6849              the relocations back out to the object file, unless
6850              they're against a section symbol, in which case we need
6851              to adjust by the section offset, or unless they're GP
6852              relative in which case we need to adjust by the amount
6853              that we're adjusting GP in this relocateable object.  */
6854
6855           if (!mips_elf_local_relocation_p (input_bfd, rel, local_sections,
6856                                             false))
6857             /* There's nothing to do for non-local relocations.  */
6858             continue;
6859
6860           if (r_type == R_MIPS16_GPREL
6861               || r_type == R_MIPS_GPREL16
6862               || r_type == R_MIPS_GPREL32
6863               || r_type == R_MIPS_LITERAL)
6864             addend -= (_bfd_get_gp_value (output_bfd)
6865                        - _bfd_get_gp_value (input_bfd));
6866           else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26
6867                    || r_type == R_MIPS_GNU_REL16_S2)
6868             /* The addend is stored without its two least
6869                significant bits (which are always zero.)  In a
6870                non-relocateable link, calculate_relocation will do
6871                this shift; here, we must do it ourselves.  */
6872             addend <<= 2;
6873
6874           r_symndx = ELF32_R_SYM (rel->r_info);
6875           sym = local_syms + r_symndx;
6876           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6877             /* Adjust the addend appropriately.  */
6878             addend += local_sections[r_symndx]->output_offset;
6879
6880           /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6881              then we only want to write out the high-order 16 bits.
6882              The subsequent R_MIPS_LO16 will handle the low-order bits.  */
6883           if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
6884               || r_type == R_MIPS_GNU_REL_HI16)
6885             addend = mips_elf_high (addend);
6886           /* If the relocation is for an R_MIPS_26 relocation, then
6887              the two low-order bits are not stored in the object file;
6888              they are implicitly zero.  */
6889           else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26
6890                    || r_type == R_MIPS_GNU_REL16_S2)
6891             addend >>= 2;
6892
6893           if (rela_relocation_p)
6894             /* If this is a RELA relocation, just update the addend.
6895                We have to cast away constness for REL.  */
6896             rel->r_addend = addend;
6897           else
6898             {
6899               /* Otherwise, we have to write the value back out.  Note
6900                  that we use the source mask, rather than the
6901                  destination mask because the place to which we are
6902                  writing will be source of the addend in the final
6903                  link.  */
6904               addend &= howto->src_mask;
6905
6906               if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
6907                 /* See the comment above about using R_MIPS_64 in the 32-bit
6908                    ABI.  Here, we need to update the addend.  It would be
6909                    possible to get away with just using the R_MIPS_32 reloc
6910                    but for endianness.  */
6911                 {
6912                   bfd_vma sign_bits;
6913                   bfd_vma low_bits;
6914                   bfd_vma high_bits;
6915
6916                   if (addend & ((bfd_vma) 1 << 31))
6917                     sign_bits = ((bfd_vma) 1 << 32) - 1;
6918                   else
6919                     sign_bits = 0;
6920
6921                   /* If we don't know that we have a 64-bit type,
6922                      do two separate stores.  */
6923                   if (bfd_big_endian (input_bfd))
6924                     {
6925                       /* Store the sign-bits (which are most significant)
6926                          first.  */
6927                       low_bits = sign_bits;
6928                       high_bits = addend;
6929                     }
6930                   else
6931                     {
6932                       low_bits = addend;
6933                       high_bits = sign_bits;
6934                     }
6935                   bfd_put_32 (input_bfd, low_bits,
6936                               contents + rel->r_offset);
6937                   bfd_put_32 (input_bfd, high_bits,
6938                               contents + rel->r_offset + 4);
6939                   continue;
6940                 }
6941
6942               if (!mips_elf_perform_relocation (info, howto, rel, addend,
6943                                                 input_bfd,  input_section,
6944                                                 contents, false))
6945                 return false;
6946             }
6947
6948           /* Go on to the next relocation.  */
6949           continue;
6950         }
6951
6952       /* In the N32 and 64-bit ABIs there may be multiple consecutive
6953          relocations for the same offset.  In that case we are
6954          supposed to treat the output of each relocation as the addend
6955          for the next.  */
6956       if (rel + 1 < relend
6957           && rel->r_offset == rel[1].r_offset
6958           && ELF32_R_TYPE (rel[1].r_info) != R_MIPS_NONE)
6959         use_saved_addend_p = true;
6960       else
6961         use_saved_addend_p = false;
6962
6963       /* Figure out what value we are supposed to relocate.  */
6964       switch (mips_elf_calculate_relocation (output_bfd,
6965                                              input_bfd,
6966                                              input_section,
6967                                              info,
6968                                              rel,
6969                                              addend,
6970                                              howto,
6971                                              local_syms,
6972                                              local_sections,
6973                                              &value,
6974                                              &name,
6975                                              &require_jalx))
6976         {
6977         case bfd_reloc_continue:
6978           /* There's nothing to do.  */
6979           continue;
6980
6981         case bfd_reloc_undefined:
6982           /* mips_elf_calculate_relocation already called the
6983              undefined_symbol callback.  There's no real point in
6984              trying to perform the relocation at this point, so we
6985              just skip ahead to the next relocation.  */
6986           continue;
6987
6988         case bfd_reloc_notsupported:
6989           abort ();
6990           break;
6991
6992         case bfd_reloc_overflow:
6993           if (use_saved_addend_p)
6994             /* Ignore overflow until we reach the last relocation for
6995                a given location.  */
6996             ;
6997           else
6998             {
6999               BFD_ASSERT (name != NULL);
7000               if (! ((*info->callbacks->reloc_overflow)
7001                      (info, name, howto->name, (bfd_vma) 0,
7002                       input_bfd, input_section, rel->r_offset)))
7003                 return false;
7004             }
7005           break;
7006
7007         case bfd_reloc_ok:
7008           break;
7009
7010         default:
7011           abort ();
7012           break;
7013         }
7014
7015       /* If we've got another relocation for the address, keep going
7016          until we reach the last one.  */
7017       if (use_saved_addend_p)
7018         {
7019           addend = value;
7020           continue;
7021         }
7022
7023       if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
7024         /* See the comment above about using R_MIPS_64 in the 32-bit
7025            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
7026            that calculated the right value.  Now, however, we
7027            sign-extend the 32-bit result to 64-bits, and store it as a
7028            64-bit value.  We are especially generous here in that we
7029            go to extreme lengths to support this usage on systems with
7030            only a 32-bit VMA.  */
7031         {
7032           bfd_vma sign_bits;
7033           bfd_vma low_bits;
7034           bfd_vma high_bits;
7035
7036           if (value & ((bfd_vma) 1 << 31))
7037             sign_bits = ((bfd_vma) 1 << 32) - 1;
7038           else
7039             sign_bits = 0;
7040
7041           /* If we don't know that we have a 64-bit type,
7042              do two separate stores.  */
7043           if (bfd_big_endian (input_bfd))
7044             {
7045               /* Undo what we did above.  */
7046               rel->r_offset -= 4;
7047               /* Store the sign-bits (which are most significant)
7048                  first.  */
7049               low_bits = sign_bits;
7050               high_bits = value;
7051             }
7052           else
7053             {
7054               low_bits = value;
7055               high_bits = sign_bits;
7056             }
7057           bfd_put_32 (input_bfd, low_bits,
7058                       contents + rel->r_offset);
7059           bfd_put_32 (input_bfd, high_bits,
7060                       contents + rel->r_offset + 4);
7061           continue;
7062         }
7063
7064       /* Actually perform the relocation.  */
7065       if (!mips_elf_perform_relocation (info, howto, rel, value, input_bfd,
7066                                         input_section, contents,
7067                                         require_jalx))
7068         return false;
7069     }
7070
7071   return true;
7072 }
7073
7074 /* This hook function is called before the linker writes out a global
7075    symbol.  We mark symbols as small common if appropriate.  This is
7076    also where we undo the increment of the value for a mips16 symbol.  */
7077
7078 boolean
7079 _bfd_mips_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
7080      bfd *abfd ATTRIBUTE_UNUSED;
7081      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7082      const char *name ATTRIBUTE_UNUSED;
7083      Elf_Internal_Sym *sym;
7084      asection *input_sec;
7085 {
7086   /* If we see a common symbol, which implies a relocatable link, then
7087      if a symbol was small common in an input file, mark it as small
7088      common in the output file.  */
7089   if (sym->st_shndx == SHN_COMMON
7090       && strcmp (input_sec->name, ".scommon") == 0)
7091     sym->st_shndx = SHN_MIPS_SCOMMON;
7092
7093   if (sym->st_other == STO_MIPS16
7094       && (sym->st_value & 1) != 0)
7095     --sym->st_value;
7096
7097   return true;
7098 }
7099 \f
7100 /* Functions for the dynamic linker.  */
7101
7102 /* The name of the dynamic interpreter.  This is put in the .interp
7103    section.  */
7104
7105 #define ELF_DYNAMIC_INTERPRETER(abfd)           \
7106    (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
7107     : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
7108     : "/usr/lib/libc.so.1")
7109
7110 /* Create dynamic sections when linking against a dynamic object.  */
7111
7112 boolean
7113 _bfd_mips_elf_create_dynamic_sections (abfd, info)
7114      bfd *abfd;
7115      struct bfd_link_info *info;
7116 {
7117   struct elf_link_hash_entry *h;
7118   flagword flags;
7119   register asection *s;
7120   const char * const *namep;
7121
7122   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7123            | SEC_LINKER_CREATED | SEC_READONLY);
7124
7125   /* Mips ABI requests the .dynamic section to be read only.  */
7126   s = bfd_get_section_by_name (abfd, ".dynamic");
7127   if (s != NULL)
7128     {
7129       if (! bfd_set_section_flags (abfd, s, flags))
7130         return false;
7131     }
7132
7133   /* We need to create .got section.  */
7134   if (! mips_elf_create_got_section (abfd, info))
7135     return false;
7136
7137   /* Create the .msym section on IRIX6.  It is used by the dynamic
7138      linker to speed up dynamic relocations, and to avoid computing
7139      the ELF hash for symbols.  */
7140   if (IRIX_COMPAT (abfd) == ict_irix6
7141       && !mips_elf_create_msym_section (abfd))
7142     return false;
7143
7144   /* Create .stub section.  */
7145   if (bfd_get_section_by_name (abfd,
7146                                MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
7147     {
7148       s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
7149       if (s == NULL
7150           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
7151           || ! bfd_set_section_alignment (abfd, s,
7152                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7153         return false;
7154     }
7155
7156   if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
7157       && !info->shared
7158       && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
7159     {
7160       s = bfd_make_section (abfd, ".rld_map");
7161       if (s == NULL
7162           || ! bfd_set_section_flags (abfd, s, flags & ~SEC_READONLY)
7163           || ! bfd_set_section_alignment (abfd, s,
7164                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7165         return false;
7166     }
7167
7168   /* On IRIX5, we adjust add some additional symbols and change the
7169      alignments of several sections.  There is no ABI documentation
7170      indicating that this is necessary on IRIX6, nor any evidence that
7171      the linker takes such action.  */
7172   if (IRIX_COMPAT (abfd) == ict_irix5)
7173     {
7174       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7175         {
7176           h = NULL;
7177           if (! (_bfd_generic_link_add_one_symbol
7178                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr,
7179                   (bfd_vma) 0, (const char *) NULL, false,
7180                   get_elf_backend_data (abfd)->collect,
7181                   (struct bfd_link_hash_entry **) &h)))
7182             return false;
7183           h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
7184           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7185           h->type = STT_SECTION;
7186
7187           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7188             return false;
7189         }
7190
7191       /* We need to create a .compact_rel section.  */
7192       if (SGI_COMPAT (abfd))
7193         {
7194           if (!mips_elf_create_compact_rel_section (abfd, info))
7195             return false;
7196         }
7197
7198       /* Change aligments of some sections.  */
7199       s = bfd_get_section_by_name (abfd, ".hash");
7200       if (s != NULL)
7201         bfd_set_section_alignment (abfd, s, 4);
7202       s = bfd_get_section_by_name (abfd, ".dynsym");
7203       if (s != NULL)
7204         bfd_set_section_alignment (abfd, s, 4);
7205       s = bfd_get_section_by_name (abfd, ".dynstr");
7206       if (s != NULL)
7207         bfd_set_section_alignment (abfd, s, 4);
7208       s = bfd_get_section_by_name (abfd, ".reginfo");
7209       if (s != NULL)
7210         bfd_set_section_alignment (abfd, s, 4);
7211       s = bfd_get_section_by_name (abfd, ".dynamic");
7212       if (s != NULL)
7213         bfd_set_section_alignment (abfd, s, 4);
7214     }
7215
7216   if (!info->shared)
7217     {
7218       h = NULL;
7219       if (SGI_COMPAT (abfd))
7220         {
7221           if (!(_bfd_generic_link_add_one_symbol
7222                 (info, abfd, "_DYNAMIC_LINK", BSF_GLOBAL, bfd_abs_section_ptr,
7223                  (bfd_vma) 0, (const char *) NULL, false,
7224                  get_elf_backend_data (abfd)->collect,
7225                  (struct bfd_link_hash_entry **) &h)))
7226             return false;
7227         }
7228       else
7229         {
7230           /* For normal mips it is _DYNAMIC_LINKING.  */
7231           if (!(_bfd_generic_link_add_one_symbol
7232                 (info, abfd, "_DYNAMIC_LINKING", BSF_GLOBAL,
7233                  bfd_abs_section_ptr, (bfd_vma) 0, (const char *) NULL, false,
7234                  get_elf_backend_data (abfd)->collect,
7235                  (struct bfd_link_hash_entry **) &h)))
7236             return false;
7237         }
7238       h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
7239       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7240       h->type = STT_SECTION;
7241
7242       if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7243         return false;
7244
7245       if (! mips_elf_hash_table (info)->use_rld_obj_head)
7246         {
7247           /* __rld_map is a four byte word located in the .data section
7248              and is filled in by the rtld to contain a pointer to
7249              the _r_debug structure. Its symbol value will be set in
7250              mips_elf_finish_dynamic_symbol.  */
7251           s = bfd_get_section_by_name (abfd, ".rld_map");
7252           BFD_ASSERT (s != NULL);
7253
7254           h = NULL;
7255           if (SGI_COMPAT (abfd))
7256             {
7257               if (!(_bfd_generic_link_add_one_symbol
7258                     (info, abfd, "__rld_map", BSF_GLOBAL, s,
7259                      (bfd_vma) 0, (const char *) NULL, false,
7260                      get_elf_backend_data (abfd)->collect,
7261                      (struct bfd_link_hash_entry **) &h)))
7262                 return false;
7263             }
7264           else
7265             {
7266               /* For normal mips the symbol is __RLD_MAP.  */
7267               if (!(_bfd_generic_link_add_one_symbol
7268                     (info, abfd, "__RLD_MAP", BSF_GLOBAL, s,
7269                      (bfd_vma) 0, (const char *) NULL, false,
7270                      get_elf_backend_data (abfd)->collect,
7271                      (struct bfd_link_hash_entry **) &h)))
7272                 return false;
7273             }
7274           h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
7275           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7276           h->type = STT_OBJECT;
7277
7278           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7279             return false;
7280         }
7281     }
7282
7283   return true;
7284 }
7285
7286 /* Create the .compact_rel section.  */
7287
7288 static boolean
7289 mips_elf_create_compact_rel_section (abfd, info)
7290      bfd *abfd;
7291      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7292 {
7293   flagword flags;
7294   register asection *s;
7295
7296   if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
7297     {
7298       flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
7299                | SEC_READONLY);
7300
7301       s = bfd_make_section (abfd, ".compact_rel");
7302       if (s == NULL
7303           || ! bfd_set_section_flags (abfd, s, flags)
7304           || ! bfd_set_section_alignment (abfd, s,
7305                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7306         return false;
7307
7308       s->_raw_size = sizeof (Elf32_External_compact_rel);
7309     }
7310
7311   return true;
7312 }
7313
7314 /* Create the .got section to hold the global offset table.  */
7315
7316 static boolean
7317 mips_elf_create_got_section (abfd, info)
7318      bfd *abfd;
7319      struct bfd_link_info *info;
7320 {
7321   flagword flags;
7322   register asection *s;
7323   struct elf_link_hash_entry *h;
7324   struct mips_got_info *g;
7325
7326   /* This function may be called more than once.  */
7327   if (mips_elf_got_section (abfd))
7328     return true;
7329
7330   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7331            | SEC_LINKER_CREATED);
7332
7333   s = bfd_make_section (abfd, ".got");
7334   if (s == NULL
7335       || ! bfd_set_section_flags (abfd, s, flags)
7336       || ! bfd_set_section_alignment (abfd, s, 4))
7337     return false;
7338
7339   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
7340      linker script because we don't want to define the symbol if we
7341      are not creating a global offset table.  */
7342   h = NULL;
7343   if (! (_bfd_generic_link_add_one_symbol
7344          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
7345           (bfd_vma) 0, (const char *) NULL, false,
7346           get_elf_backend_data (abfd)->collect,
7347           (struct bfd_link_hash_entry **) &h)))
7348     return false;
7349   h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
7350   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7351   h->type = STT_OBJECT;
7352
7353   if (info->shared
7354       && ! bfd_elf32_link_record_dynamic_symbol (info, h))
7355     return false;
7356
7357   /* The first several global offset table entries are reserved.  */
7358   s->_raw_size = MIPS_RESERVED_GOTNO * MIPS_ELF_GOT_SIZE (abfd);
7359
7360   g = (struct mips_got_info *) bfd_alloc (abfd,
7361                                           sizeof (struct mips_got_info));
7362   if (g == NULL)
7363     return false;
7364   g->global_gotsym = NULL;
7365   g->local_gotno = MIPS_RESERVED_GOTNO;
7366   g->assigned_gotno = MIPS_RESERVED_GOTNO;
7367   if (elf_section_data (s) == NULL)
7368     {
7369       s->used_by_bfd =
7370         (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
7371       if (elf_section_data (s) == NULL)
7372         return false;
7373     }
7374   elf_section_data (s)->tdata = (PTR) g;
7375   elf_section_data (s)->this_hdr.sh_flags
7376     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
7377
7378   return true;
7379 }
7380
7381 /* Returns the .msym section for ABFD, creating it if it does not
7382    already exist.  Returns NULL to indicate error.  */
7383
7384 static asection *
7385 mips_elf_create_msym_section (abfd)
7386      bfd *abfd;
7387 {
7388   asection *s;
7389
7390   s = bfd_get_section_by_name (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7391   if (!s)
7392     {
7393       s = bfd_make_section (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7394       if (!s
7395           || !bfd_set_section_flags (abfd, s,
7396                                      SEC_ALLOC
7397                                      | SEC_LOAD
7398                                      | SEC_HAS_CONTENTS
7399                                      | SEC_LINKER_CREATED
7400                                      | SEC_READONLY)
7401           || !bfd_set_section_alignment (abfd, s,
7402                                          MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7403         return NULL;
7404     }
7405
7406   return s;
7407 }
7408
7409 /* Add room for N relocations to the .rel.dyn section in ABFD.  */
7410
7411 static void
7412 mips_elf_allocate_dynamic_relocations (abfd, n)
7413      bfd *abfd;
7414      unsigned int n;
7415 {
7416   asection *s;
7417
7418   s = bfd_get_section_by_name (abfd, MIPS_ELF_REL_DYN_SECTION_NAME (abfd));
7419   BFD_ASSERT (s != NULL);
7420
7421   if (s->_raw_size == 0)
7422     {
7423       /* Make room for a null element.  */
7424       s->_raw_size += MIPS_ELF_REL_SIZE (abfd);
7425       ++s->reloc_count;
7426     }
7427   s->_raw_size += n * MIPS_ELF_REL_SIZE (abfd);
7428 }
7429
7430 /* Look through the relocs for a section during the first phase, and
7431    allocate space in the global offset table.  */
7432
7433 boolean
7434 _bfd_mips_elf_check_relocs (abfd, info, sec, relocs)
7435      bfd *abfd;
7436      struct bfd_link_info *info;
7437      asection *sec;
7438      const Elf_Internal_Rela *relocs;
7439 {
7440   const char *name;
7441   bfd *dynobj;
7442   Elf_Internal_Shdr *symtab_hdr;
7443   struct elf_link_hash_entry **sym_hashes;
7444   struct mips_got_info *g;
7445   size_t extsymoff;
7446   const Elf_Internal_Rela *rel;
7447   const Elf_Internal_Rela *rel_end;
7448   asection *sgot;
7449   asection *sreloc;
7450   struct elf_backend_data *bed;
7451
7452   if (info->relocateable)
7453     return true;
7454
7455   dynobj = elf_hash_table (info)->dynobj;
7456   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7457   sym_hashes = elf_sym_hashes (abfd);
7458   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7459
7460   /* Check for the mips16 stub sections.  */
7461
7462   name = bfd_get_section_name (abfd, sec);
7463   if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
7464     {
7465       unsigned long r_symndx;
7466
7467       /* Look at the relocation information to figure out which symbol
7468          this is for.  */
7469
7470       r_symndx = ELF32_R_SYM (relocs->r_info);
7471
7472       if (r_symndx < extsymoff
7473           || sym_hashes[r_symndx - extsymoff] == NULL)
7474         {
7475           asection *o;
7476
7477           /* This stub is for a local symbol.  This stub will only be
7478              needed if there is some relocation in this BFD, other
7479              than a 16 bit function call, which refers to this symbol.  */
7480           for (o = abfd->sections; o != NULL; o = o->next)
7481             {
7482               Elf_Internal_Rela *sec_relocs;
7483               const Elf_Internal_Rela *r, *rend;
7484
7485               /* We can ignore stub sections when looking for relocs.  */
7486               if ((o->flags & SEC_RELOC) == 0
7487                   || o->reloc_count == 0
7488                   || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
7489                               sizeof FN_STUB - 1) == 0
7490                   || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
7491                               sizeof CALL_STUB - 1) == 0
7492                   || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
7493                               sizeof CALL_FP_STUB - 1) == 0)
7494                 continue;
7495
7496               sec_relocs = (_bfd_elf32_link_read_relocs
7497                             (abfd, o, (PTR) NULL,
7498                              (Elf_Internal_Rela *) NULL,
7499                              info->keep_memory));
7500               if (sec_relocs == NULL)
7501                 return false;
7502
7503               rend = sec_relocs + o->reloc_count;
7504               for (r = sec_relocs; r < rend; r++)
7505                 if (ELF32_R_SYM (r->r_info) == r_symndx
7506                     && ELF32_R_TYPE (r->r_info) != R_MIPS16_26)
7507                   break;
7508
7509               if (! info->keep_memory)
7510                 free (sec_relocs);
7511
7512               if (r < rend)
7513                 break;
7514             }
7515
7516           if (o == NULL)
7517             {
7518               /* There is no non-call reloc for this stub, so we do
7519                  not need it.  Since this function is called before
7520                  the linker maps input sections to output sections, we
7521                  can easily discard it by setting the SEC_EXCLUDE
7522                  flag.  */
7523               sec->flags |= SEC_EXCLUDE;
7524               return true;
7525             }
7526
7527           /* Record this stub in an array of local symbol stubs for
7528              this BFD.  */
7529           if (elf_tdata (abfd)->local_stubs == NULL)
7530             {
7531               unsigned long symcount;
7532               asection **n;
7533
7534               if (elf_bad_symtab (abfd))
7535                 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
7536               else
7537                 symcount = symtab_hdr->sh_info;
7538               n = (asection **) bfd_zalloc (abfd,
7539                                             symcount * sizeof (asection *));
7540               if (n == NULL)
7541                 return false;
7542               elf_tdata (abfd)->local_stubs = n;
7543             }
7544
7545           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7546
7547           /* We don't need to set mips16_stubs_seen in this case.
7548              That flag is used to see whether we need to look through
7549              the global symbol table for stubs.  We don't need to set
7550              it here, because we just have a local stub.  */
7551         }
7552       else
7553         {
7554           struct mips_elf_link_hash_entry *h;
7555
7556           h = ((struct mips_elf_link_hash_entry *)
7557                sym_hashes[r_symndx - extsymoff]);
7558
7559           /* H is the symbol this stub is for.  */
7560
7561           h->fn_stub = sec;
7562           mips_elf_hash_table (info)->mips16_stubs_seen = true;
7563         }
7564     }
7565   else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
7566            || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7567     {
7568       unsigned long r_symndx;
7569       struct mips_elf_link_hash_entry *h;
7570       asection **loc;
7571
7572       /* Look at the relocation information to figure out which symbol
7573          this is for.  */
7574
7575       r_symndx = ELF32_R_SYM (relocs->r_info);
7576
7577       if (r_symndx < extsymoff
7578           || sym_hashes[r_symndx - extsymoff] == NULL)
7579         {
7580           /* This stub was actually built for a static symbol defined
7581              in the same file.  We assume that all static symbols in
7582              mips16 code are themselves mips16, so we can simply
7583              discard this stub.  Since this function is called before
7584              the linker maps input sections to output sections, we can
7585              easily discard it by setting the SEC_EXCLUDE flag.  */
7586           sec->flags |= SEC_EXCLUDE;
7587           return true;
7588         }
7589
7590       h = ((struct mips_elf_link_hash_entry *)
7591            sym_hashes[r_symndx - extsymoff]);
7592
7593       /* H is the symbol this stub is for.  */
7594
7595       if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7596         loc = &h->call_fp_stub;
7597       else
7598         loc = &h->call_stub;
7599
7600       /* If we already have an appropriate stub for this function, we
7601          don't need another one, so we can discard this one.  Since
7602          this function is called before the linker maps input sections
7603          to output sections, we can easily discard it by setting the
7604          SEC_EXCLUDE flag.  We can also discard this section if we
7605          happen to already know that this is a mips16 function; it is
7606          not necessary to check this here, as it is checked later, but
7607          it is slightly faster to check now.  */
7608       if (*loc != NULL || h->root.other == STO_MIPS16)
7609         {
7610           sec->flags |= SEC_EXCLUDE;
7611           return true;
7612         }
7613
7614       *loc = sec;
7615       mips_elf_hash_table (info)->mips16_stubs_seen = true;
7616     }
7617
7618   if (dynobj == NULL)
7619     {
7620       sgot = NULL;
7621       g = NULL;
7622     }
7623   else
7624     {
7625       sgot = mips_elf_got_section (dynobj);
7626       if (sgot == NULL)
7627         g = NULL;
7628       else
7629         {
7630           BFD_ASSERT (elf_section_data (sgot) != NULL);
7631           g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
7632           BFD_ASSERT (g != NULL);
7633         }
7634     }
7635
7636   sreloc = NULL;
7637   bed = get_elf_backend_data (abfd);
7638   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7639   for (rel = relocs; rel < rel_end; ++rel)
7640     {
7641       unsigned long r_symndx;
7642       int r_type;
7643       struct elf_link_hash_entry *h;
7644
7645       r_symndx = ELF32_R_SYM (rel->r_info);
7646       r_type = ELF32_R_TYPE (rel->r_info);
7647
7648       if (r_symndx < extsymoff)
7649         h = NULL;
7650       else if (r_symndx >= extsymoff + (symtab_hdr->sh_size / symtab_hdr->sh_entsize))
7651         {
7652           (*_bfd_error_handler)
7653             (_("Malformed reloc detected for section %s"), name);
7654           bfd_set_error (bfd_error_bad_value);
7655           return false;
7656         }
7657       else
7658         {
7659           h = sym_hashes[r_symndx - extsymoff];
7660
7661           /* This may be an indirect symbol created because of a version.  */
7662           if (h != NULL)
7663             {
7664               while (h->root.type == bfd_link_hash_indirect)
7665                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7666             }
7667         }
7668
7669       /* Some relocs require a global offset table.  */
7670       if (dynobj == NULL || sgot == NULL)
7671         {
7672           switch (r_type)
7673             {
7674             case R_MIPS_GOT16:
7675             case R_MIPS_CALL16:
7676             case R_MIPS_CALL_HI16:
7677             case R_MIPS_CALL_LO16:
7678             case R_MIPS_GOT_HI16:
7679             case R_MIPS_GOT_LO16:
7680             case R_MIPS_GOT_PAGE:
7681             case R_MIPS_GOT_OFST:
7682             case R_MIPS_GOT_DISP:
7683               if (dynobj == NULL)
7684                 elf_hash_table (info)->dynobj = dynobj = abfd;
7685               if (! mips_elf_create_got_section (dynobj, info))
7686                 return false;
7687               g = mips_elf_got_info (dynobj, &sgot);
7688               break;
7689
7690             case R_MIPS_32:
7691             case R_MIPS_REL32:
7692             case R_MIPS_64:
7693               if (dynobj == NULL
7694                   && (info->shared || h != NULL)
7695                   && (sec->flags & SEC_ALLOC) != 0)
7696                 elf_hash_table (info)->dynobj = dynobj = abfd;
7697               break;
7698
7699             default:
7700               break;
7701             }
7702         }
7703
7704       if (!h && (r_type == R_MIPS_CALL_LO16
7705                  || r_type == R_MIPS_GOT_LO16
7706                  || r_type == R_MIPS_GOT_DISP))
7707         {
7708           /* We may need a local GOT entry for this relocation.  We
7709              don't count R_MIPS_GOT_PAGE because we can estimate the
7710              maximum number of pages needed by looking at the size of
7711              the segment.  Similar comments apply to R_MIPS_GOT16.  We
7712              don't count R_MIPS_GOT_HI16, or R_MIPS_CALL_HI16 because
7713              these are always followed by an R_MIPS_GOT_LO16 or
7714              R_MIPS_CALL_LO16.
7715
7716              This estimation is very conservative since we can merge
7717              duplicate entries in the GOT.  In order to be less
7718              conservative, we could actually build the GOT here,
7719              rather than in relocate_section.  */
7720           g->local_gotno++;
7721           sgot->_raw_size += MIPS_ELF_GOT_SIZE (dynobj);
7722         }
7723
7724       switch (r_type)
7725         {
7726         case R_MIPS_CALL16:
7727           if (h == NULL)
7728             {
7729               (*_bfd_error_handler)
7730                 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7731                  bfd_get_filename (abfd), (unsigned long) rel->r_offset);
7732               bfd_set_error (bfd_error_bad_value);
7733               return false;
7734             }
7735           /* Fall through.  */
7736
7737         case R_MIPS_CALL_HI16:
7738         case R_MIPS_CALL_LO16:
7739           if (h != NULL)
7740             {
7741               /* This symbol requires a global offset table entry.  */
7742               if (!mips_elf_record_global_got_symbol (h, info, g))
7743                 return false;
7744
7745               /* We need a stub, not a plt entry for the undefined
7746                  function.  But we record it as if it needs plt.  See
7747                  elf_adjust_dynamic_symbol in elflink.h.  */
7748               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
7749               h->type = STT_FUNC;
7750             }
7751           break;
7752
7753         case R_MIPS_GOT16:
7754         case R_MIPS_GOT_HI16:
7755         case R_MIPS_GOT_LO16:
7756         case R_MIPS_GOT_DISP:
7757           /* This symbol requires a global offset table entry.  */
7758           if (h && !mips_elf_record_global_got_symbol (h, info, g))
7759             return false;
7760           break;
7761
7762         case R_MIPS_32:
7763         case R_MIPS_REL32:
7764         case R_MIPS_64:
7765           if ((info->shared || h != NULL)
7766               && (sec->flags & SEC_ALLOC) != 0)
7767             {
7768               if (sreloc == NULL)
7769                 {
7770                   const char *name = MIPS_ELF_REL_DYN_SECTION_NAME (dynobj);
7771
7772                   sreloc = bfd_get_section_by_name (dynobj, name);
7773                   if (sreloc == NULL)
7774                     {
7775                       sreloc = bfd_make_section (dynobj, name);
7776                       if (sreloc == NULL
7777                           || ! bfd_set_section_flags (dynobj, sreloc,
7778                                                       (SEC_ALLOC
7779                                                        | SEC_LOAD
7780                                                        | SEC_HAS_CONTENTS
7781                                                        | SEC_IN_MEMORY
7782                                                        | SEC_LINKER_CREATED
7783                                                        | SEC_READONLY))
7784                           || ! bfd_set_section_alignment (dynobj, sreloc,
7785                                                           4))
7786                         return false;
7787                     }
7788                 }
7789               if (info->shared)
7790                 /* When creating a shared object, we must copy these
7791                    reloc types into the output file as R_MIPS_REL32
7792                    relocs.  We make room for this reloc in the
7793                    .rel.dyn reloc section.  */
7794                 mips_elf_allocate_dynamic_relocations (dynobj, 1);
7795               else
7796                 {
7797                   struct mips_elf_link_hash_entry *hmips;
7798
7799                   /* We only need to copy this reloc if the symbol is
7800                      defined in a dynamic object.  */
7801                   hmips = (struct mips_elf_link_hash_entry *) h;
7802                   ++hmips->possibly_dynamic_relocs;
7803                 }
7804
7805               /* Even though we don't directly need a GOT entry for
7806                  this symbol, a symbol must have a dynamic symbol
7807                  table index greater that DT_MIPS_GOTSYM if there are
7808                  dynamic relocations against it.  */
7809               if (h != NULL
7810                   && !mips_elf_record_global_got_symbol (h, info, g))
7811                 return false;
7812             }
7813
7814           if (SGI_COMPAT (abfd))
7815             mips_elf_hash_table (info)->compact_rel_size +=
7816               sizeof (Elf32_External_crinfo);
7817           break;
7818
7819         case R_MIPS_26:
7820         case R_MIPS_GPREL16:
7821         case R_MIPS_LITERAL:
7822         case R_MIPS_GPREL32:
7823           if (SGI_COMPAT (abfd))
7824             mips_elf_hash_table (info)->compact_rel_size +=
7825               sizeof (Elf32_External_crinfo);
7826           break;
7827
7828           /* This relocation describes the C++ object vtable hierarchy.
7829              Reconstruct it for later use during GC.  */
7830         case R_MIPS_GNU_VTINHERIT:
7831           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7832             return false;
7833           break;
7834
7835           /* This relocation describes which C++ vtable entries are actually
7836              used.  Record for later use during GC.  */
7837         case R_MIPS_GNU_VTENTRY:
7838           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7839             return false;
7840           break;
7841
7842         default:
7843           break;
7844         }
7845
7846       /* If this reloc is not a 16 bit call, and it has a global
7847          symbol, then we will need the fn_stub if there is one.
7848          References from a stub section do not count.  */
7849       if (h != NULL
7850           && r_type != R_MIPS16_26
7851           && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
7852                       sizeof FN_STUB - 1) != 0
7853           && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
7854                       sizeof CALL_STUB - 1) != 0
7855           && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
7856                       sizeof CALL_FP_STUB - 1) != 0)
7857         {
7858           struct mips_elf_link_hash_entry *mh;
7859
7860           mh = (struct mips_elf_link_hash_entry *) h;
7861           mh->need_fn_stub = true;
7862         }
7863     }
7864
7865   return true;
7866 }
7867
7868 /* Return the section that should be marked against GC for a given
7869    relocation.  */
7870
7871 asection *
7872 _bfd_mips_elf_gc_mark_hook (abfd, info, rel, h, sym)
7873      bfd *abfd;
7874      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7875      Elf_Internal_Rela *rel;
7876      struct elf_link_hash_entry *h;
7877      Elf_Internal_Sym *sym;
7878 {
7879   /* ??? Do mips16 stub sections need to be handled special?  */
7880
7881   if (h != NULL)
7882     {
7883       switch (ELF32_R_TYPE (rel->r_info))
7884         {
7885         case R_MIPS_GNU_VTINHERIT:
7886         case R_MIPS_GNU_VTENTRY:
7887           break;
7888
7889         default:
7890           switch (h->root.type)
7891             {
7892             case bfd_link_hash_defined:
7893             case bfd_link_hash_defweak:
7894               return h->root.u.def.section;
7895
7896             case bfd_link_hash_common:
7897               return h->root.u.c.p->section;
7898
7899             default:
7900               break;
7901             }
7902         }
7903     }
7904   else
7905     {
7906       if (!(elf_bad_symtab (abfd)
7907             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7908           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
7909                 && sym->st_shndx != SHN_COMMON))
7910         {
7911           return bfd_section_from_elf_index (abfd, sym->st_shndx);
7912         }
7913     }
7914
7915   return NULL;
7916 }
7917
7918 /* Update the got entry reference counts for the section being removed.  */
7919
7920 boolean
7921 _bfd_mips_elf_gc_sweep_hook (abfd, info, sec, relocs)
7922      bfd *abfd ATTRIBUTE_UNUSED;
7923      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7924      asection *sec ATTRIBUTE_UNUSED;
7925      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
7926 {
7927 #if 0
7928   Elf_Internal_Shdr *symtab_hdr;
7929   struct elf_link_hash_entry **sym_hashes;
7930   bfd_signed_vma *local_got_refcounts;
7931   const Elf_Internal_Rela *rel, *relend;
7932   unsigned long r_symndx;
7933   struct elf_link_hash_entry *h;
7934
7935   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7936   sym_hashes = elf_sym_hashes (abfd);
7937   local_got_refcounts = elf_local_got_refcounts (abfd);
7938
7939   relend = relocs + sec->reloc_count;
7940   for (rel = relocs; rel < relend; rel++)
7941     switch (ELF32_R_TYPE (rel->r_info))
7942       {
7943       case R_MIPS_GOT16:
7944       case R_MIPS_CALL16:
7945       case R_MIPS_CALL_HI16:
7946       case R_MIPS_CALL_LO16:
7947       case R_MIPS_GOT_HI16:
7948       case R_MIPS_GOT_LO16:
7949         /* ??? It would seem that the existing MIPS code does no sort
7950            of reference counting or whatnot on its GOT and PLT entries,
7951            so it is not possible to garbage collect them at this time.  */
7952         break;
7953
7954       default:
7955         break;
7956       }
7957 #endif
7958
7959   return true;
7960 }
7961
7962 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7963    hiding the old indirect symbol.  Process additional relocation
7964    information.  */
7965
7966 void
7967 _bfd_mips_elf_copy_indirect_symbol (dir, ind)
7968      struct elf_link_hash_entry *dir, *ind;
7969 {
7970   struct mips_elf_link_hash_entry *dirmips, *indmips;
7971
7972   _bfd_elf_link_hash_copy_indirect (dir, ind);
7973
7974   dirmips = (struct mips_elf_link_hash_entry *) dir;
7975   indmips = (struct mips_elf_link_hash_entry *) ind;
7976   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
7977   if (dirmips->min_dyn_reloc_index == 0
7978       || (indmips->min_dyn_reloc_index != 0
7979           && indmips->min_dyn_reloc_index < dirmips->min_dyn_reloc_index))
7980     dirmips->min_dyn_reloc_index = indmips->min_dyn_reloc_index;
7981 }
7982
7983 /* Adjust a symbol defined by a dynamic object and referenced by a
7984    regular object.  The current definition is in some section of the
7985    dynamic object, but we're not including those sections.  We have to
7986    change the definition to something the rest of the link can
7987    understand.  */
7988
7989 boolean
7990 _bfd_mips_elf_adjust_dynamic_symbol (info, h)
7991      struct bfd_link_info *info;
7992      struct elf_link_hash_entry *h;
7993 {
7994   bfd *dynobj;
7995   struct mips_elf_link_hash_entry *hmips;
7996   asection *s;
7997
7998   dynobj = elf_hash_table (info)->dynobj;
7999
8000   /* Make sure we know what is going on here.  */
8001   BFD_ASSERT (dynobj != NULL
8002               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
8003                   || h->weakdef != NULL
8004                   || ((h->elf_link_hash_flags
8005                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
8006                       && (h->elf_link_hash_flags
8007                           & ELF_LINK_HASH_REF_REGULAR) != 0
8008                       && (h->elf_link_hash_flags
8009                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
8010
8011   /* If this symbol is defined in a dynamic object, we need to copy
8012      any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
8013      file.  */
8014   hmips = (struct mips_elf_link_hash_entry *) h;
8015   if (! info->relocateable
8016       && hmips->possibly_dynamic_relocs != 0
8017       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
8018     mips_elf_allocate_dynamic_relocations (dynobj,
8019                                            hmips->possibly_dynamic_relocs);
8020
8021   /* For a function, create a stub, if needed.  */
8022   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
8023     {
8024       if (! elf_hash_table (info)->dynamic_sections_created)
8025         return true;
8026
8027       /* If this symbol is not defined in a regular file, then set
8028          the symbol to the stub location.  This is required to make
8029          function pointers compare as equal between the normal
8030          executable and the shared library.  */
8031       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
8032         {
8033           /* We need .stub section.  */
8034           s = bfd_get_section_by_name (dynobj,
8035                                        MIPS_ELF_STUB_SECTION_NAME (dynobj));
8036           BFD_ASSERT (s != NULL);
8037
8038           h->root.u.def.section = s;
8039           h->root.u.def.value = s->_raw_size;
8040
8041           /* XXX Write this stub address somewhere.  */
8042           h->plt.offset = s->_raw_size;
8043
8044           /* Make room for this stub code.  */
8045           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
8046
8047           /* The last half word of the stub will be filled with the index
8048              of this symbol in .dynsym section.  */
8049           return true;
8050         }
8051     }
8052   else if ((h->type == STT_FUNC)
8053            && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
8054     {
8055       /* This will set the entry for this symbol in the GOT to 0, and
8056          the dynamic linker will take care of this.  */
8057       h->root.u.def.value = 0;
8058       return true;
8059     }
8060
8061   /* If this is a weak symbol, and there is a real definition, the
8062      processor independent code will have arranged for us to see the
8063      real definition first, and we can just use the same value.  */
8064   if (h->weakdef != NULL)
8065     {
8066       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
8067                   || h->weakdef->root.type == bfd_link_hash_defweak);
8068       h->root.u.def.section = h->weakdef->root.u.def.section;
8069       h->root.u.def.value = h->weakdef->root.u.def.value;
8070       return true;
8071     }
8072
8073   /* This is a reference to a symbol defined by a dynamic object which
8074      is not a function.  */
8075
8076   return true;
8077 }
8078
8079 /* This function is called after all the input files have been read,
8080    and the input sections have been assigned to output sections.  We
8081    check for any mips16 stub sections that we can discard.  */
8082
8083 static boolean mips_elf_check_mips16_stubs
8084   PARAMS ((struct mips_elf_link_hash_entry *, PTR));
8085
8086 boolean
8087 _bfd_mips_elf_always_size_sections (output_bfd, info)
8088      bfd *output_bfd;
8089      struct bfd_link_info *info;
8090 {
8091   asection *ri;
8092
8093   /* The .reginfo section has a fixed size.  */
8094   ri = bfd_get_section_by_name (output_bfd, ".reginfo");
8095   if (ri != NULL)
8096     bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
8097
8098   if (info->relocateable
8099       || ! mips_elf_hash_table (info)->mips16_stubs_seen)
8100     return true;
8101
8102   mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8103                                mips_elf_check_mips16_stubs,
8104                                (PTR) NULL);
8105
8106   return true;
8107 }
8108
8109 /* Check the mips16 stubs for a particular symbol, and see if we can
8110    discard them.  */
8111
8112 static boolean
8113 mips_elf_check_mips16_stubs (h, data)
8114      struct mips_elf_link_hash_entry *h;
8115      PTR data ATTRIBUTE_UNUSED;
8116 {
8117   if (h->fn_stub != NULL
8118       && ! h->need_fn_stub)
8119     {
8120       /* We don't need the fn_stub; the only references to this symbol
8121          are 16 bit calls.  Clobber the size to 0 to prevent it from
8122          being included in the link.  */
8123       h->fn_stub->_raw_size = 0;
8124       h->fn_stub->_cooked_size = 0;
8125       h->fn_stub->flags &= ~SEC_RELOC;
8126       h->fn_stub->reloc_count = 0;
8127       h->fn_stub->flags |= SEC_EXCLUDE;
8128     }
8129
8130   if (h->call_stub != NULL
8131       && h->root.other == STO_MIPS16)
8132     {
8133       /* We don't need the call_stub; this is a 16 bit function, so
8134          calls from other 16 bit functions are OK.  Clobber the size
8135          to 0 to prevent it from being included in the link.  */
8136       h->call_stub->_raw_size = 0;
8137       h->call_stub->_cooked_size = 0;
8138       h->call_stub->flags &= ~SEC_RELOC;
8139       h->call_stub->reloc_count = 0;
8140       h->call_stub->flags |= SEC_EXCLUDE;
8141     }
8142
8143   if (h->call_fp_stub != NULL
8144       && h->root.other == STO_MIPS16)
8145     {
8146       /* We don't need the call_stub; this is a 16 bit function, so
8147          calls from other 16 bit functions are OK.  Clobber the size
8148          to 0 to prevent it from being included in the link.  */
8149       h->call_fp_stub->_raw_size = 0;
8150       h->call_fp_stub->_cooked_size = 0;
8151       h->call_fp_stub->flags &= ~SEC_RELOC;
8152       h->call_fp_stub->reloc_count = 0;
8153       h->call_fp_stub->flags |= SEC_EXCLUDE;
8154     }
8155
8156   return true;
8157 }
8158
8159 /* Set the sizes of the dynamic sections.  */
8160
8161 boolean
8162 _bfd_mips_elf_size_dynamic_sections (output_bfd, info)
8163      bfd *output_bfd;
8164      struct bfd_link_info *info;
8165 {
8166   bfd *dynobj;
8167   asection *s;
8168   boolean reltext;
8169   struct mips_got_info *g = NULL;
8170
8171   dynobj = elf_hash_table (info)->dynobj;
8172   BFD_ASSERT (dynobj != NULL);
8173
8174   if (elf_hash_table (info)->dynamic_sections_created)
8175     {
8176       /* Set the contents of the .interp section to the interpreter.  */
8177       if (! info->shared)
8178         {
8179           s = bfd_get_section_by_name (dynobj, ".interp");
8180           BFD_ASSERT (s != NULL);
8181           s->_raw_size
8182             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
8183           s->contents
8184             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
8185         }
8186     }
8187
8188   /* The check_relocs and adjust_dynamic_symbol entry points have
8189      determined the sizes of the various dynamic sections.  Allocate
8190      memory for them.  */
8191   reltext = false;
8192   for (s = dynobj->sections; s != NULL; s = s->next)
8193     {
8194       const char *name;
8195       boolean strip;
8196
8197       /* It's OK to base decisions on the section name, because none
8198          of the dynobj section names depend upon the input files.  */
8199       name = bfd_get_section_name (dynobj, s);
8200
8201       if ((s->flags & SEC_LINKER_CREATED) == 0)
8202         continue;
8203
8204       strip = false;
8205
8206       if (strncmp (name, ".rel", 4) == 0)
8207         {
8208           if (s->_raw_size == 0)
8209             {
8210               /* We only strip the section if the output section name
8211                  has the same name.  Otherwise, there might be several
8212                  input sections for this output section.  FIXME: This
8213                  code is probably not needed these days anyhow, since
8214                  the linker now does not create empty output sections.  */
8215               if (s->output_section != NULL
8216                   && strcmp (name,
8217                              bfd_get_section_name (s->output_section->owner,
8218                                                    s->output_section)) == 0)
8219                 strip = true;
8220             }
8221           else
8222             {
8223               const char *outname;
8224               asection *target;
8225
8226               /* If this relocation section applies to a read only
8227                  section, then we probably need a DT_TEXTREL entry.
8228                  If the relocation section is .rel.dyn, we always
8229                  assert a DT_TEXTREL entry rather than testing whether
8230                  there exists a relocation to a read only section or
8231                  not.  */
8232               outname = bfd_get_section_name (output_bfd,
8233                                               s->output_section);
8234               target = bfd_get_section_by_name (output_bfd, outname + 4);
8235               if ((target != NULL
8236                    && (target->flags & SEC_READONLY) != 0
8237                    && (target->flags & SEC_ALLOC) != 0)
8238                   || strcmp (outname,
8239                              MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) == 0)
8240                 reltext = true;
8241
8242               /* We use the reloc_count field as a counter if we need
8243                  to copy relocs into the output file.  */
8244               if (strcmp (name,
8245                           MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) != 0)
8246                 s->reloc_count = 0;
8247             }
8248         }
8249       else if (strncmp (name, ".got", 4) == 0)
8250         {
8251           int i;
8252           bfd_size_type loadable_size = 0;
8253           bfd_size_type local_gotno;
8254           struct _bfd *sub;
8255
8256           BFD_ASSERT (elf_section_data (s) != NULL);
8257           g = (struct mips_got_info *) elf_section_data (s)->tdata;
8258           BFD_ASSERT (g != NULL);
8259
8260           /* Calculate the total loadable size of the output.  That
8261              will give us the maximum number of GOT_PAGE entries
8262              required.  */
8263           for (sub = info->input_bfds; sub; sub = sub->link_next)
8264             {
8265               asection *subsection;
8266
8267               for (subsection = sub->sections;
8268                    subsection;
8269                    subsection = subsection->next)
8270                 {
8271                   if ((subsection->flags & SEC_ALLOC) == 0)
8272                     continue;
8273                   loadable_size += (subsection->_raw_size + 0xf) & ~0xf;
8274                 }
8275             }
8276           loadable_size += MIPS_FUNCTION_STUB_SIZE;
8277
8278           /* Assume there are two loadable segments consisting of
8279              contiguous sections.  Is 5 enough?  */
8280           local_gotno = (loadable_size >> 16) + 5;
8281           if (IRIX_COMPAT (output_bfd) == ict_irix6)
8282             /* It's possible we will need GOT_PAGE entries as well as
8283                GOT16 entries.  Often, these will be able to share GOT
8284                entries, but not always.  */
8285             local_gotno *= 2;
8286
8287           g->local_gotno += local_gotno;
8288           s->_raw_size += local_gotno * MIPS_ELF_GOT_SIZE (dynobj);
8289
8290           /* There has to be a global GOT entry for every symbol with
8291              a dynamic symbol table index of DT_MIPS_GOTSYM or
8292              higher.  Therefore, it make sense to put those symbols
8293              that need GOT entries at the end of the symbol table.  We
8294              do that here.  */
8295           if (!mips_elf_sort_hash_table (info, 1))
8296             return false;
8297
8298           if (g->global_gotsym != NULL)
8299             i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
8300           else
8301             /* If there are no global symbols, or none requiring
8302                relocations, then GLOBAL_GOTSYM will be NULL.  */
8303             i = 0;
8304           g->global_gotno = i;
8305           s->_raw_size += i * MIPS_ELF_GOT_SIZE (dynobj);
8306         }
8307       else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
8308         {
8309           /* Irix rld assumes that the function stub isn't at the end
8310              of .text section. So put a dummy. XXX  */
8311           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
8312         }
8313       else if (! info->shared
8314                && ! mips_elf_hash_table (info)->use_rld_obj_head
8315                && strncmp (name, ".rld_map", 8) == 0)
8316         {
8317           /* We add a room for __rld_map. It will be filled in by the
8318              rtld to contain a pointer to the _r_debug structure.  */
8319           s->_raw_size += 4;
8320         }
8321       else if (SGI_COMPAT (output_bfd)
8322                && strncmp (name, ".compact_rel", 12) == 0)
8323         s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
8324       else if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (output_bfd))
8325                == 0)
8326         s->_raw_size = (sizeof (Elf32_External_Msym)
8327                         * (elf_hash_table (info)->dynsymcount
8328                            + bfd_count_sections (output_bfd)));
8329       else if (strncmp (name, ".init", 5) != 0)
8330         {
8331           /* It's not one of our sections, so don't allocate space.  */
8332           continue;
8333         }
8334
8335       if (strip)
8336         {
8337           _bfd_strip_section_from_output (info, s);
8338           continue;
8339         }
8340
8341       /* Allocate memory for the section contents.  */
8342       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
8343       if (s->contents == NULL && s->_raw_size != 0)
8344         {
8345           bfd_set_error (bfd_error_no_memory);
8346           return false;
8347         }
8348     }
8349
8350   if (elf_hash_table (info)->dynamic_sections_created)
8351     {
8352       /* Add some entries to the .dynamic section.  We fill in the
8353          values later, in elf_mips_finish_dynamic_sections, but we
8354          must add the entries now so that we get the correct size for
8355          the .dynamic section.  The DT_DEBUG entry is filled in by the
8356          dynamic linker and used by the debugger.  */
8357       if (! info->shared)
8358         {
8359           /* SGI object has the equivalence of DT_DEBUG in the
8360              DT_MIPS_RLD_MAP entry.  */
8361           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
8362             return false;
8363           if (!SGI_COMPAT (output_bfd))
8364             {
8365               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
8366                 return false;
8367             }
8368         }
8369       else
8370         {
8371           /* Shared libraries on traditional mips have DT_DEBUG.  */
8372           if (!SGI_COMPAT (output_bfd))
8373             {
8374               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
8375                 return false;
8376             }
8377         }
8378       if (reltext && SGI_COMPAT (output_bfd))
8379         {
8380           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
8381             return false;
8382           info->flags |= DF_TEXTREL;
8383         }
8384
8385       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
8386         return false;
8387
8388       if (bfd_get_section_by_name (dynobj,
8389                                    MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)))
8390         {
8391           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
8392             return false;
8393
8394           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
8395             return false;
8396
8397           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
8398             return false;
8399         }
8400
8401       if (SGI_COMPAT (output_bfd))
8402         {
8403           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICTNO, 0))
8404             return false;
8405         }
8406
8407       if (SGI_COMPAT (output_bfd))
8408         {
8409           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLISTNO, 0))
8410             return false;
8411         }
8412
8413       if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
8414         {
8415           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICT, 0))
8416             return false;
8417
8418           s = bfd_get_section_by_name (dynobj, ".liblist");
8419           BFD_ASSERT (s != NULL);
8420
8421           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLIST, 0))
8422             return false;
8423         }
8424
8425       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
8426         return false;
8427
8428       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
8429         return false;
8430
8431 #if 0
8432       /* Time stamps in executable files are a bad idea.  */
8433       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
8434         return false;
8435 #endif
8436
8437 #if 0 /* FIXME  */
8438       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
8439         return false;
8440 #endif
8441
8442 #if 0 /* FIXME  */
8443       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
8444         return false;
8445 #endif
8446
8447       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
8448         return false;
8449
8450       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
8451         return false;
8452
8453       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
8454         return false;
8455
8456       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
8457         return false;
8458
8459       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
8460         return false;
8461
8462       if (IRIX_COMPAT (dynobj) == ict_irix5
8463           && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
8464         return false;
8465
8466       if (IRIX_COMPAT (dynobj) == ict_irix6
8467           && (bfd_get_section_by_name
8468               (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
8469           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
8470         return false;
8471
8472       if (bfd_get_section_by_name (dynobj,
8473                                    MIPS_ELF_MSYM_SECTION_NAME (dynobj))
8474           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_MSYM, 0))
8475         return false;
8476     }
8477
8478   return true;
8479 }
8480
8481 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8482    adjust it appropriately now.  */
8483
8484 static void
8485 mips_elf_irix6_finish_dynamic_symbol (abfd, name, sym)
8486      bfd *abfd ATTRIBUTE_UNUSED;
8487      const char *name;
8488      Elf_Internal_Sym *sym;
8489 {
8490   /* The linker script takes care of providing names and values for
8491      these, but we must place them into the right sections.  */
8492   static const char* const text_section_symbols[] = {
8493     "_ftext",
8494     "_etext",
8495     "__dso_displacement",
8496     "__elf_header",
8497     "__program_header_table",
8498     NULL
8499   };
8500
8501   static const char* const data_section_symbols[] = {
8502     "_fdata",
8503     "_edata",
8504     "_end",
8505     "_fbss",
8506     NULL
8507   };
8508
8509   const char* const *p;
8510   int i;
8511
8512   for (i = 0; i < 2; ++i)
8513     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
8514          *p;
8515          ++p)
8516       if (strcmp (*p, name) == 0)
8517         {
8518           /* All of these symbols are given type STT_SECTION by the
8519              IRIX6 linker.  */
8520           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8521
8522           /* The IRIX linker puts these symbols in special sections.  */
8523           if (i == 0)
8524             sym->st_shndx = SHN_MIPS_TEXT;
8525           else
8526             sym->st_shndx = SHN_MIPS_DATA;
8527
8528           break;
8529         }
8530 }
8531
8532 /* Finish up dynamic symbol handling.  We set the contents of various
8533    dynamic sections here.  */
8534
8535 boolean
8536 _bfd_mips_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
8537      bfd *output_bfd;
8538      struct bfd_link_info *info;
8539      struct elf_link_hash_entry *h;
8540      Elf_Internal_Sym *sym;
8541 {
8542   bfd *dynobj;
8543   bfd_vma gval;
8544   asection *sgot;
8545   asection *smsym;
8546   struct mips_got_info *g;
8547   const char *name;
8548   struct mips_elf_link_hash_entry *mh;
8549
8550   dynobj = elf_hash_table (info)->dynobj;
8551   gval = sym->st_value;
8552   mh = (struct mips_elf_link_hash_entry *) h;
8553
8554   if (h->plt.offset != (bfd_vma) -1)
8555     {
8556       asection *s;
8557       bfd_byte *p;
8558       bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
8559
8560       /* This symbol has a stub.  Set it up.  */
8561
8562       BFD_ASSERT (h->dynindx != -1);
8563
8564       s = bfd_get_section_by_name (dynobj,
8565                                    MIPS_ELF_STUB_SECTION_NAME (dynobj));
8566       BFD_ASSERT (s != NULL);
8567
8568       /* Fill the stub.  */
8569       p = stub;
8570       bfd_put_32 (output_bfd, STUB_LW (output_bfd), p);
8571       p += 4;
8572       bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), p);
8573       p += 4;
8574
8575       /* FIXME: Can h->dynindex be more than 64K?  */
8576       if (h->dynindx & 0xffff0000)
8577         return false;
8578
8579       bfd_put_32 (output_bfd, STUB_JALR, p);
8580       p += 4;
8581       bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, p);
8582
8583       BFD_ASSERT (h->plt.offset <= s->_raw_size);
8584       memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
8585
8586       /* Mark the symbol as undefined.  plt.offset != -1 occurs
8587          only for the referenced symbol.  */
8588       sym->st_shndx = SHN_UNDEF;
8589
8590       /* The run-time linker uses the st_value field of the symbol
8591          to reset the global offset table entry for this external
8592          to its stub address when unlinking a shared object.  */
8593       gval = s->output_section->vma + s->output_offset + h->plt.offset;
8594       sym->st_value = gval;
8595     }
8596
8597   BFD_ASSERT (h->dynindx != -1
8598               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
8599
8600   sgot = mips_elf_got_section (dynobj);
8601   BFD_ASSERT (sgot != NULL);
8602   BFD_ASSERT (elf_section_data (sgot) != NULL);
8603   g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8604   BFD_ASSERT (g != NULL);
8605
8606   /* Run through the global symbol table, creating GOT entries for all
8607      the symbols that need them.  */
8608   if (g->global_gotsym != NULL
8609       && h->dynindx >= g->global_gotsym->dynindx)
8610     {
8611       bfd_vma offset;
8612       bfd_vma value;
8613
8614       if (sym->st_value)
8615         value = sym->st_value;
8616       else
8617         {
8618           /* For an entity defined in a shared object, this will be
8619              NULL.  (For functions in shared objects for
8620              which we have created stubs, ST_VALUE will be non-NULL.
8621              That's because such the functions are now no longer defined
8622              in a shared object.)  */
8623
8624           if (info->shared && h->root.type == bfd_link_hash_undefined)
8625             value = 0;
8626           else
8627             value = h->root.u.def.value;
8628         }
8629       offset = mips_elf_global_got_index (dynobj, h);
8630       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
8631     }
8632
8633   /* Create a .msym entry, if appropriate.  */
8634   smsym = bfd_get_section_by_name (dynobj,
8635                                    MIPS_ELF_MSYM_SECTION_NAME (dynobj));
8636   if (smsym)
8637     {
8638       Elf32_Internal_Msym msym;
8639
8640       msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
8641       /* It is undocumented what the `1' indicates, but IRIX6 uses
8642          this value.  */
8643       msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
8644       bfd_mips_elf_swap_msym_out
8645         (dynobj, &msym,
8646          ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
8647     }
8648
8649   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
8650   name = h->root.root.string;
8651   if (strcmp (name, "_DYNAMIC") == 0
8652       || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
8653     sym->st_shndx = SHN_ABS;
8654   else if (strcmp (name, "_DYNAMIC_LINK") == 0
8655            || strcmp (name, "_DYNAMIC_LINKING") == 0)
8656     {
8657       sym->st_shndx = SHN_ABS;
8658       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8659       sym->st_value = 1;
8660     }
8661   else if (strcmp (name, "_gp_disp") == 0)
8662     {
8663       sym->st_shndx = SHN_ABS;
8664       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8665       sym->st_value = elf_gp (output_bfd);
8666     }
8667   else if (SGI_COMPAT (output_bfd))
8668     {
8669       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
8670           || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
8671         {
8672           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8673           sym->st_other = STO_PROTECTED;
8674           sym->st_value = 0;
8675           sym->st_shndx = SHN_MIPS_DATA;
8676         }
8677       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
8678         {
8679           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8680           sym->st_other = STO_PROTECTED;
8681           sym->st_value = mips_elf_hash_table (info)->procedure_count;
8682           sym->st_shndx = SHN_ABS;
8683         }
8684       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
8685         {
8686           if (h->type == STT_FUNC)
8687             sym->st_shndx = SHN_MIPS_TEXT;
8688           else if (h->type == STT_OBJECT)
8689             sym->st_shndx = SHN_MIPS_DATA;
8690         }
8691     }
8692
8693   /* Handle the IRIX6-specific symbols.  */
8694   if (IRIX_COMPAT (output_bfd) == ict_irix6)
8695     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
8696
8697   if (! info->shared)
8698     {
8699       if (! mips_elf_hash_table (info)->use_rld_obj_head
8700           && (strcmp (name, "__rld_map") == 0
8701               || strcmp (name, "__RLD_MAP") == 0))
8702         {
8703           asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
8704           BFD_ASSERT (s != NULL);
8705           sym->st_value = s->output_section->vma + s->output_offset;
8706           bfd_put_32 (output_bfd, (bfd_vma) 0, s->contents);
8707           if (mips_elf_hash_table (info)->rld_value == 0)
8708             mips_elf_hash_table (info)->rld_value = sym->st_value;
8709         }
8710       else if (mips_elf_hash_table (info)->use_rld_obj_head
8711                && strcmp (name, "__rld_obj_head") == 0)
8712         {
8713           /* IRIX6 does not use a .rld_map section.  */
8714           if (IRIX_COMPAT (output_bfd) == ict_irix5
8715               || IRIX_COMPAT (output_bfd) == ict_none)
8716             BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
8717                         != NULL);
8718           mips_elf_hash_table (info)->rld_value = sym->st_value;
8719         }
8720     }
8721
8722   /* If this is a mips16 symbol, force the value to be even.  */
8723   if (sym->st_other == STO_MIPS16
8724       && (sym->st_value & 1) != 0)
8725     --sym->st_value;
8726
8727   return true;
8728 }
8729
8730 /* Finish up the dynamic sections.  */
8731
8732 boolean
8733 _bfd_mips_elf_finish_dynamic_sections (output_bfd, info)
8734      bfd *output_bfd;
8735      struct bfd_link_info *info;
8736 {
8737   bfd *dynobj;
8738   asection *sdyn;
8739   asection *sgot;
8740   struct mips_got_info *g;
8741
8742   dynobj = elf_hash_table (info)->dynobj;
8743
8744   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8745
8746   sgot = mips_elf_got_section (dynobj);
8747   if (sgot == NULL)
8748     g = NULL;
8749   else
8750     {
8751       BFD_ASSERT (elf_section_data (sgot) != NULL);
8752       g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8753       BFD_ASSERT (g != NULL);
8754     }
8755
8756   if (elf_hash_table (info)->dynamic_sections_created)
8757     {
8758       bfd_byte *b;
8759
8760       BFD_ASSERT (sdyn != NULL);
8761       BFD_ASSERT (g != NULL);
8762
8763       for (b = sdyn->contents;
8764            b < sdyn->contents + sdyn->_raw_size;
8765            b += MIPS_ELF_DYN_SIZE (dynobj))
8766         {
8767           Elf_Internal_Dyn dyn;
8768           const char *name;
8769           size_t elemsize;
8770           asection *s;
8771           boolean swap_out_p;
8772
8773           /* Read in the current dynamic entry.  */
8774           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
8775
8776           /* Assume that we're going to modify it and write it out.  */
8777           swap_out_p = true;
8778
8779           switch (dyn.d_tag)
8780             {
8781             case DT_RELENT:
8782               s = (bfd_get_section_by_name
8783                    (dynobj,
8784                     MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)));
8785               BFD_ASSERT (s != NULL);
8786               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
8787               break;
8788
8789             case DT_STRSZ:
8790               /* Rewrite DT_STRSZ.  */
8791               dyn.d_un.d_val =
8792                 _bfd_stringtab_size (elf_hash_table (info)->dynstr);
8793               break;
8794
8795             case DT_PLTGOT:
8796               name = ".got";
8797               goto get_vma;
8798             case DT_MIPS_CONFLICT:
8799               name = ".conflict";
8800               goto get_vma;
8801             case DT_MIPS_LIBLIST:
8802               name = ".liblist";
8803             get_vma:
8804               s = bfd_get_section_by_name (output_bfd, name);
8805               BFD_ASSERT (s != NULL);
8806               dyn.d_un.d_ptr = s->vma;
8807               break;
8808
8809             case DT_MIPS_RLD_VERSION:
8810               dyn.d_un.d_val = 1; /* XXX */
8811               break;
8812
8813             case DT_MIPS_FLAGS:
8814               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
8815               break;
8816
8817             case DT_MIPS_CONFLICTNO:
8818               name = ".conflict";
8819               elemsize = sizeof (Elf32_Conflict);
8820               goto set_elemno;
8821
8822             case DT_MIPS_LIBLISTNO:
8823               name = ".liblist";
8824               elemsize = sizeof (Elf32_Lib);
8825             set_elemno:
8826               s = bfd_get_section_by_name (output_bfd, name);
8827               if (s != NULL)
8828                 {
8829                   if (s->_cooked_size != 0)
8830                     dyn.d_un.d_val = s->_cooked_size / elemsize;
8831                   else
8832                     dyn.d_un.d_val = s->_raw_size / elemsize;
8833                 }
8834               else
8835                 dyn.d_un.d_val = 0;
8836               break;
8837
8838             case DT_MIPS_TIME_STAMP:
8839               time ((time_t *) &dyn.d_un.d_val);
8840               break;
8841
8842             case DT_MIPS_ICHECKSUM:
8843               /* XXX FIXME: */
8844               swap_out_p = false;
8845               break;
8846
8847             case DT_MIPS_IVERSION:
8848               /* XXX FIXME: */
8849               swap_out_p = false;
8850               break;
8851
8852             case DT_MIPS_BASE_ADDRESS:
8853               s = output_bfd->sections;
8854               BFD_ASSERT (s != NULL);
8855               dyn.d_un.d_ptr = s->vma & ~(0xffff);
8856               break;
8857
8858             case DT_MIPS_LOCAL_GOTNO:
8859               dyn.d_un.d_val = g->local_gotno;
8860               break;
8861
8862             case DT_MIPS_UNREFEXTNO:
8863               /* The index into the dynamic symbol table which is the
8864                  entry of the first external symbol that is not
8865                  referenced within the same object.  */
8866               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
8867               break;
8868
8869             case DT_MIPS_GOTSYM:
8870               if (g->global_gotsym)
8871                 {
8872                   dyn.d_un.d_val = g->global_gotsym->dynindx;
8873                   break;
8874                 }
8875               /* In case if we don't have global got symbols we default
8876                  to setting DT_MIPS_GOTSYM to the same value as
8877                  DT_MIPS_SYMTABNO, so we just fall through.  */
8878
8879             case DT_MIPS_SYMTABNO:
8880               name = ".dynsym";
8881               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
8882               s = bfd_get_section_by_name (output_bfd, name);
8883               BFD_ASSERT (s != NULL);
8884
8885               if (s->_cooked_size != 0)
8886                 dyn.d_un.d_val = s->_cooked_size / elemsize;
8887               else
8888                 dyn.d_un.d_val = s->_raw_size / elemsize;
8889               break;
8890
8891             case DT_MIPS_HIPAGENO:
8892               dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
8893               break;
8894
8895             case DT_MIPS_RLD_MAP:
8896               dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
8897               break;
8898
8899             case DT_MIPS_OPTIONS:
8900               s = (bfd_get_section_by_name
8901                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
8902               dyn.d_un.d_ptr = s->vma;
8903               break;
8904
8905             case DT_MIPS_MSYM:
8906               s = (bfd_get_section_by_name
8907                    (output_bfd, MIPS_ELF_MSYM_SECTION_NAME (output_bfd)));
8908               dyn.d_un.d_ptr = s->vma;
8909               break;
8910
8911             default:
8912               swap_out_p = false;
8913               break;
8914             }
8915
8916           if (swap_out_p)
8917             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
8918               (dynobj, &dyn, b);
8919         }
8920     }
8921
8922   /* The first entry of the global offset table will be filled at
8923      runtime. The second entry will be used by some runtime loaders.
8924      This isn't the case of Irix rld.  */
8925   if (sgot != NULL && sgot->_raw_size > 0)
8926     {
8927       MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
8928       MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
8929                          sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
8930     }
8931
8932   if (sgot != NULL)
8933     elf_section_data (sgot->output_section)->this_hdr.sh_entsize
8934       = MIPS_ELF_GOT_SIZE (output_bfd);
8935
8936   {
8937     asection *smsym;
8938     asection *s;
8939     Elf32_compact_rel cpt;
8940
8941     /* ??? The section symbols for the output sections were set up in
8942        _bfd_elf_final_link.  SGI sets the STT_NOTYPE attribute for these
8943        symbols.  Should we do so?  */
8944
8945     smsym = bfd_get_section_by_name (dynobj,
8946                                      MIPS_ELF_MSYM_SECTION_NAME (dynobj));
8947     if (smsym != NULL)
8948       {
8949         Elf32_Internal_Msym msym;
8950
8951         msym.ms_hash_value = 0;
8952         msym.ms_info = ELF32_MS_INFO (0, 1);
8953
8954         for (s = output_bfd->sections; s != NULL; s = s->next)
8955           {
8956             long dynindx = elf_section_data (s)->dynindx;
8957
8958             bfd_mips_elf_swap_msym_out
8959               (output_bfd, &msym,
8960                (((Elf32_External_Msym *) smsym->contents)
8961                 + dynindx));
8962           }
8963       }
8964
8965     if (SGI_COMPAT (output_bfd))
8966       {
8967         /* Write .compact_rel section out.  */
8968         s = bfd_get_section_by_name (dynobj, ".compact_rel");
8969         if (s != NULL)
8970           {
8971             cpt.id1 = 1;
8972             cpt.num = s->reloc_count;
8973             cpt.id2 = 2;
8974             cpt.offset = (s->output_section->filepos
8975                           + sizeof (Elf32_External_compact_rel));
8976             cpt.reserved0 = 0;
8977             cpt.reserved1 = 0;
8978             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
8979                                             ((Elf32_External_compact_rel *)
8980                                              s->contents));
8981
8982             /* Clean up a dummy stub function entry in .text.  */
8983             s = bfd_get_section_by_name (dynobj,
8984                                          MIPS_ELF_STUB_SECTION_NAME (dynobj));
8985             if (s != NULL)
8986               {
8987                 file_ptr dummy_offset;
8988
8989                 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
8990                 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
8991                 memset (s->contents + dummy_offset, 0,
8992                         MIPS_FUNCTION_STUB_SIZE);
8993               }
8994           }
8995       }
8996
8997     /* We need to sort the entries of the dynamic relocation section.  */
8998
8999     if (!ABI_64_P (output_bfd))
9000       {
9001         asection *reldyn;
9002
9003         reldyn = bfd_get_section_by_name (dynobj,
9004                                           MIPS_ELF_REL_DYN_SECTION_NAME (dynobj));
9005         if (reldyn != NULL && reldyn->reloc_count > 2)
9006           {
9007             reldyn_sorting_bfd = output_bfd;
9008             qsort ((Elf32_External_Rel *) reldyn->contents + 1,
9009                    (size_t) reldyn->reloc_count - 1,
9010                    sizeof (Elf32_External_Rel), sort_dynamic_relocs);
9011           }
9012       }
9013
9014     /* Clean up a first relocation in .rel.dyn.  */
9015     s = bfd_get_section_by_name (dynobj,
9016                                  MIPS_ELF_REL_DYN_SECTION_NAME (dynobj));
9017     if (s != NULL && s->_raw_size > 0)
9018       memset (s->contents, 0, MIPS_ELF_REL_SIZE (dynobj));
9019   }
9020
9021   return true;
9022 }
9023 \f
9024 /* This is almost identical to bfd_generic_get_... except that some
9025    MIPS relocations need to be handled specially.  Sigh.  */
9026
9027 static bfd_byte *
9028 elf32_mips_get_relocated_section_contents (abfd, link_info, link_order, data,
9029                                            relocateable, symbols)
9030      bfd *abfd;
9031      struct bfd_link_info *link_info;
9032      struct bfd_link_order *link_order;
9033      bfd_byte *data;
9034      boolean relocateable;
9035      asymbol **symbols;
9036 {
9037   /* Get enough memory to hold the stuff */
9038   bfd *input_bfd = link_order->u.indirect.section->owner;
9039   asection *input_section = link_order->u.indirect.section;
9040
9041   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
9042   arelent **reloc_vector = NULL;
9043   long reloc_count;
9044
9045   if (reloc_size < 0)
9046     goto error_return;
9047
9048   reloc_vector = (arelent **) bfd_malloc (reloc_size);
9049   if (reloc_vector == NULL && reloc_size != 0)
9050     goto error_return;
9051
9052   /* read in the section */
9053   if (!bfd_get_section_contents (input_bfd,
9054                                  input_section,
9055                                  (PTR) data,
9056                                  0,
9057                                  input_section->_raw_size))
9058     goto error_return;
9059
9060   /* We're not relaxing the section, so just copy the size info */
9061   input_section->_cooked_size = input_section->_raw_size;
9062   input_section->reloc_done = true;
9063
9064   reloc_count = bfd_canonicalize_reloc (input_bfd,
9065                                         input_section,
9066                                         reloc_vector,
9067                                         symbols);
9068   if (reloc_count < 0)
9069     goto error_return;
9070
9071   if (reloc_count > 0)
9072     {
9073       arelent **parent;
9074       /* for mips */
9075       int gp_found;
9076       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
9077
9078       {
9079         struct bfd_hash_entry *h;
9080         struct bfd_link_hash_entry *lh;
9081         /* Skip all this stuff if we aren't mixing formats.  */
9082         if (abfd && input_bfd
9083             && abfd->xvec == input_bfd->xvec)
9084           lh = 0;
9085         else
9086           {
9087             h = bfd_hash_lookup (&link_info->hash->table, "_gp", false, false);
9088             lh = (struct bfd_link_hash_entry *) h;
9089           }
9090       lookup:
9091         if (lh)
9092           {
9093             switch (lh->type)
9094               {
9095               case bfd_link_hash_undefined:
9096               case bfd_link_hash_undefweak:
9097               case bfd_link_hash_common:
9098                 gp_found = 0;
9099                 break;
9100               case bfd_link_hash_defined:
9101               case bfd_link_hash_defweak:
9102                 gp_found = 1;
9103                 gp = lh->u.def.value;
9104                 break;
9105               case bfd_link_hash_indirect:
9106               case bfd_link_hash_warning:
9107                 lh = lh->u.i.link;
9108                 /* @@FIXME  ignoring warning for now */
9109                 goto lookup;
9110               case bfd_link_hash_new:
9111               default:
9112                 abort ();
9113               }
9114           }
9115         else
9116           gp_found = 0;
9117       }
9118       /* end mips */
9119       for (parent = reloc_vector; *parent != (arelent *) NULL;
9120            parent++)
9121         {
9122           char *error_message = (char *) NULL;
9123           bfd_reloc_status_type r;
9124
9125           /* Specific to MIPS: Deal with relocation types that require
9126              knowing the gp of the output bfd.  */
9127           asymbol *sym = *(*parent)->sym_ptr_ptr;
9128           if (bfd_is_abs_section (sym->section) && abfd)
9129             {
9130               /* The special_function wouldn't get called anyways.  */
9131             }
9132           else if (!gp_found)
9133             {
9134               /* The gp isn't there; let the special function code
9135                  fall over on its own.  */
9136             }
9137           else if ((*parent)->howto->special_function
9138                    == _bfd_mips_elf_gprel16_reloc)
9139             {
9140               /* bypass special_function call */
9141               r = gprel16_with_gp (input_bfd, sym, *parent, input_section,
9142                                    relocateable, (PTR) data, gp);
9143               goto skip_bfd_perform_relocation;
9144             }
9145           /* end mips specific stuff */
9146
9147           r = bfd_perform_relocation (input_bfd,
9148                                       *parent,
9149                                       (PTR) data,
9150                                       input_section,
9151                                       relocateable ? abfd : (bfd *) NULL,
9152                                       &error_message);
9153         skip_bfd_perform_relocation:
9154
9155           if (relocateable)
9156             {
9157               asection *os = input_section->output_section;
9158
9159               /* A partial link, so keep the relocs */
9160               os->orelocation[os->reloc_count] = *parent;
9161               os->reloc_count++;
9162             }
9163
9164           if (r != bfd_reloc_ok)
9165             {
9166               switch (r)
9167                 {
9168                 case bfd_reloc_undefined:
9169                   if (!((*link_info->callbacks->undefined_symbol)
9170                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
9171                          input_bfd, input_section, (*parent)->address,
9172                          true)))
9173                     goto error_return;
9174                   break;
9175                 case bfd_reloc_dangerous:
9176                   BFD_ASSERT (error_message != (char *) NULL);
9177                   if (!((*link_info->callbacks->reloc_dangerous)
9178                         (link_info, error_message, input_bfd, input_section,
9179                          (*parent)->address)))
9180                     goto error_return;
9181                   break;
9182                 case bfd_reloc_overflow:
9183                   if (!((*link_info->callbacks->reloc_overflow)
9184                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
9185                          (*parent)->howto->name, (*parent)->addend,
9186                          input_bfd, input_section, (*parent)->address)))
9187                     goto error_return;
9188                   break;
9189                 case bfd_reloc_outofrange:
9190                 default:
9191                   abort ();
9192                   break;
9193                 }
9194
9195             }
9196         }
9197     }
9198   if (reloc_vector != NULL)
9199     free (reloc_vector);
9200   return data;
9201
9202 error_return:
9203   if (reloc_vector != NULL)
9204     free (reloc_vector);
9205   return NULL;
9206 }
9207
9208 #define bfd_elf32_bfd_get_relocated_section_contents \
9209   elf32_mips_get_relocated_section_contents
9210 \f
9211 /* ECOFF swapping routines.  These are used when dealing with the
9212    .mdebug section, which is in the ECOFF debugging format.  */
9213 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap = {
9214   /* Symbol table magic number.  */
9215   magicSym,
9216   /* Alignment of debugging information.  E.g., 4.  */
9217   4,
9218   /* Sizes of external symbolic information.  */
9219   sizeof (struct hdr_ext),
9220   sizeof (struct dnr_ext),
9221   sizeof (struct pdr_ext),
9222   sizeof (struct sym_ext),
9223   sizeof (struct opt_ext),
9224   sizeof (struct fdr_ext),
9225   sizeof (struct rfd_ext),
9226   sizeof (struct ext_ext),
9227   /* Functions to swap in external symbolic data.  */
9228   ecoff_swap_hdr_in,
9229   ecoff_swap_dnr_in,
9230   ecoff_swap_pdr_in,
9231   ecoff_swap_sym_in,
9232   ecoff_swap_opt_in,
9233   ecoff_swap_fdr_in,
9234   ecoff_swap_rfd_in,
9235   ecoff_swap_ext_in,
9236   _bfd_ecoff_swap_tir_in,
9237   _bfd_ecoff_swap_rndx_in,
9238   /* Functions to swap out external symbolic data.  */
9239   ecoff_swap_hdr_out,
9240   ecoff_swap_dnr_out,
9241   ecoff_swap_pdr_out,
9242   ecoff_swap_sym_out,
9243   ecoff_swap_opt_out,
9244   ecoff_swap_fdr_out,
9245   ecoff_swap_rfd_out,
9246   ecoff_swap_ext_out,
9247   _bfd_ecoff_swap_tir_out,
9248   _bfd_ecoff_swap_rndx_out,
9249   /* Function to read in symbolic data.  */
9250   _bfd_mips_elf_read_ecoff_info
9251 };
9252 \f
9253 #define TARGET_LITTLE_SYM               bfd_elf32_littlemips_vec
9254 #define TARGET_LITTLE_NAME              "elf32-littlemips"
9255 #define TARGET_BIG_SYM                  bfd_elf32_bigmips_vec
9256 #define TARGET_BIG_NAME                 "elf32-bigmips"
9257 #define ELF_ARCH                        bfd_arch_mips
9258 #define ELF_MACHINE_CODE                EM_MIPS
9259
9260 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
9261    a value of 0x1000, and we are compatible.  */
9262 #define ELF_MAXPAGESIZE                 0x1000
9263
9264 #define elf_backend_collect             true
9265 #define elf_backend_type_change_ok      true
9266 #define elf_backend_can_gc_sections     true
9267 #define elf_backend_sign_extend_vma     true
9268 #define elf_info_to_howto               mips_info_to_howto_rela
9269 #define elf_info_to_howto_rel           mips_info_to_howto_rel
9270 #define elf_backend_sym_is_global       mips_elf_sym_is_global
9271 #define elf_backend_object_p            _bfd_mips_elf_object_p
9272 #define elf_backend_section_from_shdr   _bfd_mips_elf_section_from_shdr
9273 #define elf_backend_fake_sections       _bfd_mips_elf_fake_sections
9274 #define elf_backend_section_from_bfd_section \
9275                                         _bfd_mips_elf_section_from_bfd_section
9276 #define elf_backend_section_processing  _bfd_mips_elf_section_processing
9277 #define elf_backend_symbol_processing   _bfd_mips_elf_symbol_processing
9278 #define elf_backend_additional_program_headers \
9279                                         _bfd_mips_elf_additional_program_headers
9280 #define elf_backend_modify_segment_map  _bfd_mips_elf_modify_segment_map
9281 #define elf_backend_final_write_processing \
9282                                         _bfd_mips_elf_final_write_processing
9283 #define elf_backend_ecoff_debug_swap    &mips_elf32_ecoff_debug_swap
9284 #define elf_backend_add_symbol_hook     _bfd_mips_elf_add_symbol_hook
9285 #define elf_backend_create_dynamic_sections \
9286                                         _bfd_mips_elf_create_dynamic_sections
9287 #define elf_backend_check_relocs        _bfd_mips_elf_check_relocs
9288 #define elf_backend_adjust_dynamic_symbol \
9289                                         _bfd_mips_elf_adjust_dynamic_symbol
9290 #define elf_backend_always_size_sections \
9291                                         _bfd_mips_elf_always_size_sections
9292 #define elf_backend_size_dynamic_sections \
9293                                         _bfd_mips_elf_size_dynamic_sections
9294 #define elf_backend_relocate_section    _bfd_mips_elf_relocate_section
9295 #define elf_backend_link_output_symbol_hook \
9296                                         _bfd_mips_elf_link_output_symbol_hook
9297 #define elf_backend_finish_dynamic_symbol \
9298                                         _bfd_mips_elf_finish_dynamic_symbol
9299 #define elf_backend_finish_dynamic_sections \
9300                                         _bfd_mips_elf_finish_dynamic_sections
9301 #define elf_backend_gc_mark_hook        _bfd_mips_elf_gc_mark_hook
9302 #define elf_backend_gc_sweep_hook       _bfd_mips_elf_gc_sweep_hook
9303
9304 #define elf_backend_got_header_size     (4*MIPS_RESERVED_GOTNO)
9305 #define elf_backend_plt_header_size     0
9306
9307 #define elf_backend_copy_indirect_symbol \
9308                                         _bfd_mips_elf_copy_indirect_symbol
9309
9310 #define elf_backend_hide_symbol         _bfd_mips_elf_hide_symbol
9311
9312 #define bfd_elf32_bfd_is_local_label_name \
9313                                         mips_elf_is_local_label_name
9314 #define bfd_elf32_find_nearest_line     _bfd_mips_elf_find_nearest_line
9315 #define bfd_elf32_set_section_contents  _bfd_mips_elf_set_section_contents
9316 #define bfd_elf32_bfd_link_hash_table_create \
9317                                         _bfd_mips_elf_link_hash_table_create
9318 #define bfd_elf32_bfd_final_link        _bfd_mips_elf_final_link
9319 #define bfd_elf32_bfd_copy_private_bfd_data \
9320                                         _bfd_mips_elf_copy_private_bfd_data
9321 #define bfd_elf32_bfd_merge_private_bfd_data \
9322                                         _bfd_mips_elf_merge_private_bfd_data
9323 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
9324 #define bfd_elf32_bfd_print_private_bfd_data \
9325                                         _bfd_mips_elf_print_private_bfd_data
9326 #include "elf32-target.h"
9327
9328 /* Support for traditional mips targets */
9329
9330 #define INCLUDED_TARGET_FILE            /* More a type of flag */
9331
9332 #undef TARGET_LITTLE_SYM
9333 #undef TARGET_LITTLE_NAME
9334 #undef TARGET_BIG_SYM
9335 #undef TARGET_BIG_NAME
9336
9337 #define TARGET_LITTLE_SYM               bfd_elf32_tradlittlemips_vec
9338 #define TARGET_LITTLE_NAME              "elf32-tradlittlemips"
9339 #define TARGET_BIG_SYM                  bfd_elf32_tradbigmips_vec
9340 #define TARGET_BIG_NAME                 "elf32-tradbigmips"
9341
9342 /* Include the target file again for this target */
9343 #include "elf32-target.h"