bfd/elf32-mips.c

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