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 const Elf_Internal_Rela *mips_elf_next_lo16_relocation
 169   PARAMS ((const Elf_Internal_Rela *, const Elf_Internal_Rela *));
 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 = 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 /* Returns the first R_MIPS_LO16 relocation found, beginning with
5567    RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
5568
5569 static const Elf_Internal_Rela *
5570 mips_elf_next_lo16_relocation (relocation, relend)
5571      const Elf_Internal_Rela *relocation;
5572      const Elf_Internal_Rela *relend;
5573 {
5574   /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5575      immediately following.  However, for the IRIX6 ABI, the next
5576      relocation may be a composed relocation consisting of several
5577      relocations for the same address.  In that case, the R_MIPS_LO16
5578      relocation may occur as one of these.  We permit a similar
5579      extension in general, as that is useful for GCC.  */
5580   while (relocation < relend)
5581     {
5582       if (ELF32_R_TYPE (relocation->r_info) == R_MIPS_LO16)
5583         return relocation;
5584
5585       ++relocation;
5586     }
5587
5588   /* We didn't find it.  */
5589   bfd_set_error (bfd_error_bad_value);
5590   return NULL;
5591 }
5592
5593 /* Create a rel.dyn relocation for the dynamic linker to resolve.  The
5594    relocatin is against the symbol with the dynamic symbol table index
5595    DYNINDX.  REL is the original relocation, which is now being made
5596    dynamic.  */
5597
5598 static unsigned int
5599 mips_elf_create_dynamic_relocation (output_bfd, info, rel, dynindx,
5600                                     addend, input_section)
5601      bfd *output_bfd;
5602      struct bfd_link_info *info;
5603      const Elf_Internal_Rela *rel;
5604      long dynindx;
5605      bfd_vma addend;
5606      asection *input_section;
5607 {
5608   Elf_Internal_Rel outrel;
5609   boolean skip;
5610   asection *sreloc;
5611   bfd *dynobj;
5612   int r_type;
5613
5614   r_type = ELF32_R_TYPE (rel->r_info);
5615   dynobj = elf_hash_table (info)->dynobj;
5616   sreloc
5617     = bfd_get_section_by_name (dynobj,
5618                                MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd));
5619   BFD_ASSERT (sreloc != NULL);
5620
5621   skip = false;
5622
5623   /* The symbol for the relocation is the same as it was for the
5624      original relocation.  */
5625   outrel.r_info = ELF32_R_INFO (dynindx, R_MIPS_REL32);
5626
5627   /* The offset for the dynamic relocation is the same as for the
5628      original relocation, adjusted by the offset at which the original
5629      section is output.  */
5630   if (elf_section_data (input_section)->stab_info == NULL)
5631     outrel.r_offset = rel->r_offset;
5632   else
5633     {
5634       bfd_vma off;
5635
5636       off = (_bfd_stab_section_offset
5637              (output_bfd, &elf_hash_table (info)->stab_info,
5638               input_section,
5639               &elf_section_data (input_section)->stab_info,
5640               rel->r_offset));
5641       if (off == (bfd_vma) -1)
5642         skip = true;
5643       outrel.r_offset = off;
5644     }
5645   outrel.r_offset += (input_section->output_section->vma
5646                       + input_section->output_offset);
5647
5648   /* If we've decided to skip this relocation, just output an emtpy
5649      record.  */
5650   if (skip)
5651     memset (&outrel, 0, sizeof (outrel));
5652
5653   if (ABI_64_P (output_bfd))
5654     {
5655       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
5656         (output_bfd, &outrel,
5657          (sreloc->contents
5658           + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
5659     }
5660   else
5661     bfd_elf32_swap_reloc_out (output_bfd, &outrel,
5662                               (((Elf32_External_Rel *)
5663                                 sreloc->contents)
5664                                + sreloc->reloc_count));
5665   ++sreloc->reloc_count;
5666
5667   /* Make sure the output section is writable.  The dynamic linker
5668      will be writing to it.  */
5669   elf_section_data (input_section->output_section)->this_hdr.sh_flags
5670     |= SHF_WRITE;
5671
5672   /* On IRIX5, make an entry of compact relocation info.  */
5673   if (! skip && IRIX_COMPAT (output_bfd) == ict_irix5)
5674     {
5675       asection* scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
5676       bfd_byte *cr;
5677
5678       if (scpt)
5679         {
5680           Elf32_crinfo cptrel;
5681
5682           mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
5683           cptrel.vaddr = (rel->r_offset
5684                           + input_section->output_section->vma
5685                           + input_section->output_offset);
5686           if (r_type == R_MIPS_REL32)
5687             mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
5688           else
5689             mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
5690           mips_elf_set_cr_dist2to (cptrel, 0);
5691           cptrel.konst = addend;
5692
5693           cr = (scpt->contents
5694                 + sizeof (Elf32_External_compact_rel));
5695           bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
5696                                      ((Elf32_External_crinfo *) cr
5697                                       + scpt->reloc_count));
5698           ++scpt->reloc_count;
5699         }
5700     }
5701
5702   return sreloc->reloc_count - 1;
5703 }
5704
5705 /* Calculate the value produced by the RELOCATION (which comes from
5706    the INPUT_BFD).  The ADDEND is the addend to use for this
5707    RELOCATION; RELOCATION->R_ADDEND is ignored.
5708
5709    The result of the relocation calculation is stored in VALUEP.
5710    REQUIRE_JALXP indicates whether or not the opcode used with this
5711    relocation must be JALX.
5712
5713    This function returns bfd_reloc_continue if the caller need take no
5714    further action regarding this relocation, bfd_reloc_notsupported if
5715    something goes dramatically wrong, bfd_reloc_overflow if an
5716    overflow occurs, and bfd_reloc_ok to indicate success.  */
5717
5718 static bfd_reloc_status_type
5719 mips_elf_calculate_relocation (abfd,
5720                                input_bfd,
5721                                input_section,
5722                                info,
5723                                relocation,
5724                                addend,
5725                                howto,
5726                                local_syms,
5727                                local_sections,
5728                                valuep,
5729                                namep,
5730                                require_jalxp)
5731      bfd *abfd;
5732      bfd *input_bfd;
5733      asection *input_section;
5734      struct bfd_link_info *info;
5735      const Elf_Internal_Rela *relocation;
5736      bfd_vma addend;
5737      reloc_howto_type *howto;
5738      Elf_Internal_Sym *local_syms;
5739      asection **local_sections;
5740      bfd_vma *valuep;
5741      const char **namep;
5742      boolean *require_jalxp;
5743 {
5744   /* The eventual value we will return.  */
5745   bfd_vma value;
5746   /* The address of the symbol against which the relocation is
5747      occurring.  */
5748   bfd_vma symbol = 0;
5749   /* The final GP value to be used for the relocatable, executable, or
5750      shared object file being produced.  */
5751   bfd_vma gp = (bfd_vma) - 1;
5752   /* The place (section offset or address) of the storage unit being
5753      relocated.  */
5754   bfd_vma p;
5755   /* The value of GP used to create the relocatable object.  */
5756   bfd_vma gp0 = (bfd_vma) - 1;
5757   /* The offset into the global offset table at which the address of
5758      the relocation entry symbol, adjusted by the addend, resides
5759      during execution.  */
5760   bfd_vma g = (bfd_vma) - 1;
5761   /* The section in which the symbol referenced by the relocation is
5762      located.  */
5763   asection *sec = NULL;
5764   struct mips_elf_link_hash_entry* h = NULL;
5765   /* True if the symbol referred to by this relocation is a local
5766      symbol.  */
5767   boolean local_p;
5768   /* True if the symbol referred to by this relocation is "_gp_disp".  */
5769   boolean gp_disp_p = false;
5770   Elf_Internal_Shdr *symtab_hdr;
5771   size_t extsymoff;
5772   unsigned long r_symndx;
5773   int r_type;
5774   /* True if overflow occurred during the calculation of the
5775      relocation value.  */
5776   boolean overflowed_p;
5777   /* True if this relocation refers to a MIPS16 function.  */
5778   boolean target_is_16_bit_code_p = false;
5779
5780   /* Parse the relocation.  */
5781   r_symndx = ELF32_R_SYM (relocation->r_info);
5782   r_type = ELF32_R_TYPE (relocation->r_info);
5783   p = (input_section->output_section->vma
5784        + input_section->output_offset
5785        + relocation->r_offset);
5786
5787   /* Assume that there will be no overflow.  */
5788   overflowed_p = false;
5789
5790   /* Figure out whether or not the symbol is local, and get the offset
5791      used in the array of hash table entries.  */
5792   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5793   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5794                                          local_sections);
5795   if (! elf_bad_symtab (input_bfd))
5796     extsymoff = symtab_hdr->sh_info;
5797   else
5798     {
5799       /* The symbol table does not follow the rule that local symbols
5800          must come before globals.  */
5801       extsymoff = 0;
5802     }
5803
5804   /* Figure out the value of the symbol.  */
5805   if (local_p)
5806     {
5807       Elf_Internal_Sym *sym;
5808
5809       sym = local_syms + r_symndx;
5810       sec = local_sections[r_symndx];
5811
5812       symbol = sec->output_section->vma + sec->output_offset;
5813       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
5814         symbol += sym->st_value;
5815
5816       /* MIPS16 text labels should be treated as odd.  */
5817       if (sym->st_other == STO_MIPS16)
5818         ++symbol;
5819
5820       /* Record the name of this symbol, for our caller.  */
5821       *namep = bfd_elf_string_from_elf_section (input_bfd,
5822                                                 symtab_hdr->sh_link,
5823                                                 sym->st_name);
5824       if (*namep == '\0')
5825         *namep = bfd_section_name (input_bfd, sec);
5826
5827       target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
5828     }
5829   else
5830     {
5831       /* For global symbols we look up the symbol in the hash-table.  */
5832       h = ((struct mips_elf_link_hash_entry *)
5833            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5834       /* Find the real hash-table entry for this symbol.  */
5835       while (h->root.type == bfd_link_hash_indirect
5836              || h->root.type == bfd_link_hash_warning)
5837         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5838
5839       /* Record the name of this symbol, for our caller.  */
5840       *namep = h->root.root.root.string;
5841
5842       /* See if this is the special _gp_disp symbol.  Note that such a
5843          symbol must always be a global symbol.  */
5844       if (strcmp (h->root.root.root.string, "_gp_disp") == 0)
5845         {
5846           /* Relocations against _gp_disp are permitted only with
5847              R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
5848           if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16)
5849             return bfd_reloc_notsupported;
5850
5851           gp_disp_p = true;
5852         }
5853       /* If this symbol is defined, calculate its address.  Note that
5854          _gp_disp is a magic symbol, always implicitly defined by the
5855          linker, so it's inappropriate to check to see whether or not
5856          its defined.  */
5857       else if ((h->root.root.type == bfd_link_hash_defined
5858                 || h->root.root.type == bfd_link_hash_defweak)
5859                && h->root.root.u.def.section)
5860         {
5861           sec = h->root.root.u.def.section;
5862           if (sec->output_section)
5863             symbol = (h->root.root.u.def.value
5864                       + sec->output_section->vma
5865                       + sec->output_offset);
5866           else
5867             symbol = h->root.root.u.def.value;
5868         }
5869       else if (h->root.root.type == bfd_link_hash_undefweak)
5870         /* We allow relocations against undefined weak symbols, giving
5871            it the value zero, so that you can undefined weak functions
5872            and check to see if they exist by looking at their
5873            addresses.  */
5874         symbol = 0;
5875       else if (info->shared && !info->symbolic && !info->no_undefined)
5876         relocation = 0;
5877       else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0)
5878         {
5879           /* If this is a dynamic link, we should have created a
5880              _DYNAMIC_LINK symbol in mips_elf_create_dynamic_sections.
5881              Otherwise, we should define the symbol with a value of 0.
5882              FIXME: It should probably get into the symbol table
5883              somehow as well.  */
5884           BFD_ASSERT (! info->shared);
5885           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5886           relocation = 0;
5887         }
5888       else
5889         {
5890           (*info->callbacks->undefined_symbol)
5891             (info, h->root.root.root.string, input_bfd,
5892              input_section, relocation->r_offset);
5893           return bfd_reloc_undefined;
5894         }
5895
5896       target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
5897     }
5898
5899   /* If this is a 32-bit call to a 16-bit function with a stub, we
5900      need to redirect the call to the stub, unless we're already *in*
5901      a stub.  */
5902   if (r_type != R_MIPS16_26 && !info->relocateable
5903       && ((h != NULL && h->fn_stub != NULL)
5904           || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
5905               && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5906       && !mips_elf_stub_section_p (input_bfd, input_section))
5907     {
5908       /* This is a 32-bit call to a 16-bit function.  We should
5909          have already noticed that we were going to need the
5910          stub.  */
5911       if (local_p)
5912         sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
5913       else
5914         {
5915           BFD_ASSERT (h->need_fn_stub);
5916           sec = h->fn_stub;
5917         }
5918
5919       symbol = sec->output_section->vma + sec->output_offset;
5920     }
5921   /* If this is a 16-bit call to a 32-bit function with a stub, we
5922      need to redirect the call to the stub.  */
5923   else if (r_type == R_MIPS16_26 && !info->relocateable
5924            && h != NULL
5925            && (h->call_stub != NULL || h->call_fp_stub != NULL)
5926            && !target_is_16_bit_code_p)
5927     {
5928       /* If both call_stub and call_fp_stub are defined, we can figure
5929          out which one to use by seeing which one appears in the input
5930          file.  */
5931       if (h->call_stub != NULL && h->call_fp_stub != NULL)
5932         {
5933           asection *o;
5934
5935           sec = NULL;
5936           for (o = input_bfd->sections; o != NULL; o = o->next)
5937             {
5938               if (strncmp (bfd_get_section_name (input_bfd, o),
5939                            CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5940                 {
5941                   sec = h->call_fp_stub;
5942                   break;
5943                 }
5944             }
5945           if (sec == NULL)
5946             sec = h->call_stub;
5947         }
5948       else if (h->call_stub != NULL)
5949         sec = h->call_stub;
5950       else
5951         sec = h->call_fp_stub;
5952
5953       BFD_ASSERT (sec->_raw_size > 0);
5954       symbol = sec->output_section->vma + sec->output_offset;
5955     }
5956
5957   /* Calls from 16-bit code to 32-bit code and vice versa require the
5958      special jalx instruction.  */
5959   *require_jalxp = (!info->relocateable
5960                     && ((r_type == R_MIPS16_26) != target_is_16_bit_code_p));
5961
5962   /* If we haven't already determined the GOT offset, or the GP value,
5963      and we're going to need it, get it now.  */
5964   switch (r_type)
5965     {
5966     case R_MIPS_CALL16:
5967     case R_MIPS_GOT16:
5968     case R_MIPS_GOT_DISP:
5969     case R_MIPS_GOT_HI16:
5970     case R_MIPS_CALL_HI16:
5971     case R_MIPS_GOT_LO16:
5972     case R_MIPS_CALL_LO16:
5973       /* Find the index into the GOT where this value is located.  */
5974       if (!local_p)
5975         {
5976           BFD_ASSERT (addend == 0);
5977           g = mips_elf_global_got_index
5978             (elf_hash_table (info)->dynobj,
5979              (struct elf_link_hash_entry*) h);
5980         }
5981       else if (r_type == R_MIPS_GOT16)
5982         /* There's no need to create a local GOT entry here; the
5983            calculation for a local GOT16 entry does not involve G.  */
5984         break;
5985       else
5986         {
5987           g = mips_elf_local_got_index (abfd, info, symbol + addend);
5988           if (g == (bfd_vma) -1)
5989             return false;
5990         }
5991
5992       /* Convert GOT indices to actual offsets.  */
5993       g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
5994                                           abfd, g);
5995       break;
5996
5997     case R_MIPS_HI16:
5998     case R_MIPS_LO16:
5999     case R_MIPS_GPREL16:
6000     case R_MIPS_GPREL32:
6001       gp0 = _bfd_get_gp_value (input_bfd);
6002       gp = _bfd_get_gp_value (abfd);
6003       break;
6004
6005     default:
6006       break;
6007     }
6008
6009   /* Figure out what kind of relocation is being performed.  */
6010   switch (r_type)
6011     {
6012     case R_MIPS_NONE:
6013       return bfd_reloc_continue;
6014
6015     case R_MIPS_16:
6016       value = symbol + mips_elf_sign_extend (addend, 16);
6017       overflowed_p = mips_elf_overflow_p (value, 16);
6018       break;
6019
6020     case R_MIPS_32:
6021     case R_MIPS_REL32:
6022     case R_MIPS_64:
6023       /* If we're creating a shared library, or this relocation is
6024          against a symbol in a shared library, then we can't know
6025          where the symbol will end up.  So, we create a relocation
6026          record in the output, and leave the job up to the dynamic
6027          linker.  */
6028       if (info->shared || !sec->output_section)
6029         {
6030           unsigned int reloc_index;
6031
6032           BFD_ASSERT (h != NULL);
6033           reloc_index
6034             = mips_elf_create_dynamic_relocation (abfd,
6035                                                   info,
6036                                                   relocation,
6037                                                   h->root.dynindx,
6038                                                   addend,
6039                                                   input_section);
6040           if (h->min_dyn_reloc_index == 0
6041               || reloc_index < h->min_dyn_reloc_index)
6042             h->min_dyn_reloc_index = reloc_index;
6043           value = symbol + addend;
6044         }
6045       else
6046         {
6047           if (r_type != R_MIPS_REL32)
6048             value = symbol + addend;
6049           else
6050             value = addend;
6051         }
6052       value &= howto->dst_mask;
6053       break;
6054
6055     case R_MIPS16_26:
6056       /* The calculation for R_MIPS_26 is just the same as for an
6057          R_MIPS_26.  It's only the storage of the relocated field into
6058          the output file that's different.  That's handled in
6059          mips_elf_perform_relocation.  So, we just fall through to the
6060          R_MIPS_26 case here.  */
6061     case R_MIPS_26:
6062       if (local_p)
6063         value = (((addend << 2) | (p & 0xf0000000)) + symbol) >> 2;
6064       else
6065         value = (mips_elf_sign_extend (addend << 2, 28) + symbol) >> 2;
6066       value &= howto->dst_mask;
6067       break;
6068
6069     case R_MIPS_HI16:
6070       if (!gp_disp_p)
6071         {
6072           value = mips_elf_high (addend + symbol);
6073           value &= howto->dst_mask;
6074         }
6075       else
6076         {
6077           value = mips_elf_high (addend + gp - p);
6078           overflowed_p = mips_elf_overflow_p (value, 16);
6079         }
6080       break;
6081
6082     case R_MIPS_LO16:
6083       if (!gp_disp_p)
6084         value = (symbol + addend) & howto->dst_mask;
6085       else
6086         {
6087           value = addend + gp - p + 4;
6088           /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6089              for overflow.  But, on, say, Irix 5, relocations against
6090              _gp_disp are normally generated from the .cpload
6091              pseudo-op.  It generates code that normally looks like
6092              this:
6093
6094                lui    $gp,%hi(_gp_disp)
6095                addiu  $gp,$gp,%lo(_gp_disp)
6096                addu   $gp,$gp,$t9
6097
6098              Here $t9 holds the address of the function being called,
6099              as required by the MIPS ELF ABI.  The R_MIPS_LO16
6100              relocation can easily overflow in this situation, but the
6101              R_MIPS_HI16 relocation will handle the overflow.
6102              Therefore, we consider this a bug in the MIPS ABI, and do
6103              not check for overflow here.  */
6104         }
6105       break;
6106
6107     case R_MIPS_LITERAL:
6108       /* Because we don't merge literal sections, we can handle this
6109          just like R_MIPS_GPREL16.  In the long run, we should merge
6110          shared literals, and then we will need to additional work
6111          here.  */
6112
6113       /* Fall through.  */
6114
6115     case R_MIPS16_GPREL:
6116       /* The R_MIPS16_GPREL performs the same calculation as
6117          R_MIPS_GPREL16, but stores the relocated bits in a different
6118          order.  We don't need to do anything special here; the
6119          differences are handled in mips_elf_perform_relocation.  */
6120     case R_MIPS_GPREL16:
6121       if (local_p)
6122         value = mips_elf_sign_extend (addend, 16) + symbol + gp0 - gp;
6123       else
6124         value = mips_elf_sign_extend (addend, 16) + symbol - gp;
6125       overflowed_p = mips_elf_overflow_p (value, 16);
6126       break;
6127
6128     case R_MIPS_GOT16:
6129       if (local_p)
6130         {
6131           value = mips_elf_got16_entry (abfd, info, symbol + addend);
6132           if (value == (bfd_vma) -1)
6133             return false;
6134           value
6135             = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6136                                               abfd,
6137                                               value);
6138           overflowed_p = mips_elf_overflow_p (value, 16);
6139           break;
6140         }
6141
6142       /* Fall through.  */
6143
6144     case R_MIPS_CALL16:
6145     case R_MIPS_GOT_DISP:
6146       value = g;
6147       overflowed_p = mips_elf_overflow_p (value, 16);
6148       break;
6149
6150     case R_MIPS_GPREL32:
6151       value = (addend + symbol + gp0 - gp) & howto->dst_mask;
6152       break;
6153
6154     case R_MIPS_PC16:
6155       value = mips_elf_sign_extend (addend, 16) + symbol - p;
6156       overflowed_p = mips_elf_overflow_p (value, 16);
6157       break;
6158
6159     case R_MIPS_GOT_HI16:
6160     case R_MIPS_CALL_HI16:
6161       /* We're allowed to handle these two relocations identically.
6162          The dynamic linker is allowed to handle the CALL relocations
6163          differently by creating a lazy evaluation stub.  */
6164       value = g;
6165       value = mips_elf_high (value);
6166       value &= howto->dst_mask;
6167       break;
6168
6169     case R_MIPS_GOT_LO16:
6170     case R_MIPS_CALL_LO16:
6171       value = g & howto->dst_mask;
6172       break;
6173
6174     case R_MIPS_GOT_PAGE:
6175       value = mips_elf_got_page (abfd, info, symbol + addend, NULL);
6176       if (value == (bfd_vma) -1)
6177         return false;
6178       value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6179                                               abfd,
6180                                               value);
6181       overflowed_p = mips_elf_overflow_p (value, 16);
6182       break;
6183
6184     case R_MIPS_GOT_OFST:
6185       mips_elf_got_page (abfd, info, symbol + addend, &value);
6186       overflowed_p = mips_elf_overflow_p (value, 16);
6187       break;
6188
6189     case R_MIPS_SUB:
6190       value = symbol - addend;
6191       value &= howto->dst_mask;
6192       break;
6193
6194     case R_MIPS_HIGHER:
6195       value = mips_elf_higher (addend + symbol);
6196       value &= howto->dst_mask;
6197       break;
6198
6199     case R_MIPS_HIGHEST:
6200       value = mips_elf_highest (addend + symbol);
6201       value &= howto->dst_mask;
6202       break;
6203
6204     case R_MIPS_SCN_DISP:
6205       value = symbol + addend - sec->output_offset;
6206       value &= howto->dst_mask;
6207       break;
6208
6209     case R_MIPS_PJUMP:
6210     case R_MIPS_JALR:
6211       /* Both of these may be ignored.  R_MIPS_JALR is an optimization
6212          hint; we could improve performance by honoring that hint.  */
6213       return bfd_reloc_continue;
6214
6215     case R_MIPS_GNU_VTINHERIT:
6216     case R_MIPS_GNU_VTENTRY:
6217       /* We don't do anything with these at present.  */
6218       return bfd_reloc_continue;
6219
6220     default:
6221       /* An unrecognized relocation type.  */
6222       return bfd_reloc_notsupported;
6223     }
6224
6225   /* Store the VALUE for our caller.  */
6226   *valuep = value;
6227   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6228 }
6229
6230 /* Obtain the field relocated by RELOCATION.  */
6231
6232 static bfd_vma
6233 mips_elf_obtain_contents (howto, relocation, input_bfd, contents)
6234      reloc_howto_type *howto;
6235      const Elf_Internal_Rela *relocation;
6236      bfd *input_bfd;
6237      bfd_byte *contents;
6238 {
6239   bfd_vma x;
6240   bfd_byte *location = contents + relocation->r_offset;
6241
6242   /* Obtain the bytes.  */
6243   x = bfd_get (8 * bfd_get_reloc_size (howto), input_bfd, location);
6244
6245   if ((ELF32_R_TYPE (relocation->r_info) == R_MIPS16_26
6246        || ELF32_R_TYPE (relocation->r_info) == R_MIPS16_GPREL)
6247       && bfd_little_endian (input_bfd))
6248     /* The two 16-bit words will be reversed on a little-endian
6249        system.  See mips_elf_perform_relocation for more details.  */
6250     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6251
6252   return x;
6253 }
6254
6255 /* It has been determined that the result of the RELOCATION is the
6256    VALUE.  Use HOWTO to place VALUE into the output file at the
6257    appropriate position.  The SECTION is the section to which the
6258    relocation applies.  If REQUIRE_JALX is true, then the opcode used
6259    for the relocation must be either JAL or JALX, and it is
6260    unconditionally converted to JALX.
6261
6262    Returns false if anything goes wrong.  */
6263
6264 static boolean
6265 mips_elf_perform_relocation (info, howto, relocation, value,
6266                              input_bfd, input_section,
6267                              contents, require_jalx)
6268      struct bfd_link_info *info;
6269      reloc_howto_type *howto;
6270      const Elf_Internal_Rela *relocation;
6271      bfd_vma value;
6272      bfd *input_bfd;
6273      asection *input_section;
6274      bfd_byte *contents;
6275      boolean require_jalx;
6276 {
6277   bfd_vma x;
6278   bfd_byte *location;
6279   int r_type = ELF32_R_TYPE (relocation->r_info);
6280
6281   /* Figure out where the relocation is occurring.  */
6282   location = contents + relocation->r_offset;
6283
6284   /* Obtain the current value.  */
6285   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
6286
6287   /* Clear the field we are setting.  */
6288   x &= ~howto->dst_mask;
6289
6290   /* If this is the R_MIPS16_26 relocation, we must store the
6291      value in a funny way.  */
6292   if (r_type == R_MIPS16_26)
6293     {
6294       /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6295          Most mips16 instructions are 16 bits, but these instructions
6296          are 32 bits.
6297
6298          The format of these instructions is:
6299
6300          +--------------+--------------------------------+
6301          !     JALX     ! X!   Imm 20:16  !   Imm 25:21  !
6302          +--------------+--------------------------------+
6303          !                Immediate  15:0                   !
6304          +-----------------------------------------------+
6305
6306          JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
6307          Note that the immediate value in the first word is swapped.
6308
6309          When producing a relocateable object file, R_MIPS16_26 is
6310          handled mostly like R_MIPS_26.  In particular, the addend is
6311          stored as a straight 26-bit value in a 32-bit instruction.
6312          (gas makes life simpler for itself by never adjusting a
6313          R_MIPS16_26 reloc to be against a section, so the addend is
6314          always zero).  However, the 32 bit instruction is stored as 2
6315          16-bit values, rather than a single 32-bit value.  In a
6316          big-endian file, the result is the same; in a little-endian
6317          file, the two 16-bit halves of the 32 bit value are swapped.
6318          This is so that a disassembler can recognize the jal
6319          instruction.
6320
6321          When doing a final link, R_MIPS16_26 is treated as a 32 bit
6322          instruction stored as two 16-bit values.  The addend A is the
6323          contents of the targ26 field.  The calculation is the same as
6324          R_MIPS_26.  When storing the calculated value, reorder the
6325          immediate value as shown above, and don't forget to store the
6326          value as two 16-bit values.
6327
6328          To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6329          defined as
6330
6331          big-endian:
6332          +--------+----------------------+
6333          |        |                      |
6334          |        |    targ26-16         |
6335          |31    26|25                   0|
6336          +--------+----------------------+
6337
6338          little-endian:
6339          +----------+------+-------------+
6340          |          |      |             |
6341          |  sub1    |      |     sub2    |
6342          |0        9|10  15|16         31|
6343          +----------+--------------------+
6344          where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6345          ((sub1 << 16) | sub2)).
6346
6347          When producing a relocateable object file, the calculation is
6348          (((A < 2) | (P & 0xf0000000) + S) >> 2)
6349          When producing a fully linked file, the calculation is
6350          let R = (((A < 2) | (P & 0xf0000000) + S) >> 2)
6351          ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)  */
6352
6353       if (!info->relocateable)
6354         /* Shuffle the bits according to the formula above.  */
6355         value = (((value & 0x1f0000) << 5)
6356                  | ((value & 0x3e00000) >> 5)
6357                  | (value & 0xffff));
6358
6359     }
6360   else if (r_type == R_MIPS16_GPREL)
6361     {
6362       /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6363          mode.  A typical instruction will have a format like this:
6364
6365          +--------------+--------------------------------+
6366          !    EXTEND    !     Imm 10:5    !   Imm 15:11  !
6367          +--------------+--------------------------------+
6368          !    Major     !   rx   !   ry   !   Imm  4:0   !
6369          +--------------+--------------------------------+
6370
6371          EXTEND is the five bit value 11110.  Major is the instruction
6372          opcode.
6373
6374          This is handled exactly like R_MIPS_GPREL16, except that the
6375          addend is retrieved and stored as shown in this diagram; that
6376          is, the Imm fields above replace the V-rel16 field.
6377
6378          All we need to do here is shuffle the bits appropriately.  As
6379          above, the two 16-bit halves must be swapped on a
6380          little-endian system.  */
6381       value = (((value & 0x7e0) << 16)
6382                | ((value & 0xf800) << 5)
6383                | (value & 0x1f));
6384     }
6385
6386   /* Set the field.  */
6387   x |= (value & howto->dst_mask);
6388
6389   /* If required, turn JAL into JALX.  */
6390   if (require_jalx)
6391     {
6392       boolean ok;
6393       bfd_vma opcode = x >> 26;
6394       bfd_vma jalx_opcode;
6395
6396       /* Check to see if the opcode is already JAL or JALX.  */
6397       if (r_type == R_MIPS16_26)
6398         {
6399           ok = ((opcode == 0x6) || (opcode == 0x7));
6400           jalx_opcode = 0x7;
6401         }
6402       else
6403         {
6404           ok = ((opcode == 0x3) || (opcode == 0x1d));
6405           jalx_opcode = 0x1d;
6406         }
6407
6408       /* If the opcode is not JAL or JALX, there's a problem.  */
6409       if (!ok)
6410         {
6411           (*_bfd_error_handler)
6412             (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6413              bfd_get_filename (input_bfd),
6414              input_section->name,
6415              (unsigned long) relocation->r_offset);
6416           bfd_set_error (bfd_error_bad_value);
6417           return false;
6418         }
6419
6420       /* Make this the JALX opcode.  */
6421       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6422     }
6423
6424   /* Swap the high- and low-order 16 bits on little-endian systems
6425      when doing a MIPS16 relocation.  */
6426   if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
6427       && bfd_little_endian (input_bfd))
6428     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6429
6430   /* Put the value into the output.  */
6431   bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
6432   return true;
6433 }
6434
6435 /* Returns true if SECTION is a MIPS16 stub section.  */
6436
6437 static boolean
6438 mips_elf_stub_section_p (abfd, section)
6439      bfd *abfd ATTRIBUTE_UNUSED;
6440      asection *section;
6441 {
6442   const char *name = bfd_get_section_name (abfd, section);
6443
6444   return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
6445           || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
6446           || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
6447 }
6448
6449 /* Relocate a MIPS ELF section.  */
6450
6451 boolean
6452 _bfd_mips_elf_relocate_section (output_bfd, info, input_bfd, input_section,
6453                                 contents, relocs, local_syms, local_sections)
6454      bfd *output_bfd;
6455      struct bfd_link_info *info;
6456      bfd *input_bfd;
6457      asection *input_section;
6458      bfd_byte *contents;
6459      Elf_Internal_Rela *relocs;
6460      Elf_Internal_Sym *local_syms;
6461      asection **local_sections;
6462 {
6463   Elf_Internal_Rela *rel;
6464   const Elf_Internal_Rela *relend;
6465   bfd_vma addend;
6466   bfd_vma last_hi16_addend;
6467   boolean use_saved_addend_p = false;
6468   boolean last_hi16_addend_valid_p = false;
6469   struct elf_backend_data *bed;
6470
6471   bed = get_elf_backend_data (output_bfd);
6472   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6473   for (rel = relocs; rel < relend; ++rel)
6474     {
6475       const char *name;
6476       bfd_vma value;
6477       reloc_howto_type *howto;
6478       boolean require_jalx;
6479       /* True if the relocation is a RELA relocation, rather than a
6480          REL relocation.  */
6481       boolean rela_relocation_p = true;
6482       int r_type = ELF32_R_TYPE (rel->r_info);
6483
6484       /* Find the relocation howto for this relocation.  */
6485       if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
6486         /* Some 32-bit code uses R_MIPS_64.  In particular, people use
6487            64-bit code, but make sure all their addresses are in the
6488            lowermost or uppermost 32-bit section of the 64-bit address
6489            space.  Thus, when they use an R_MIPS_64 they mean what is
6490            usually meant by R_MIPS_32, with the exception that the
6491            stored value is sign-extended to 64 bits.  */
6492         howto = elf_mips_howto_table + R_MIPS_32;
6493       else
6494         howto = mips_rtype_to_howto (r_type);
6495
6496       if (!use_saved_addend_p)
6497         {
6498           Elf_Internal_Shdr *rel_hdr;
6499
6500           /* If these relocations were originally of the REL variety,
6501              we must pull the addend out of the field that will be
6502              relocated.  Otherwise, we simply use the contents of the
6503              RELA relocation.  To determine which flavor or relocation
6504              this is, we depend on the fact that the INPUT_SECTION's
6505              REL_HDR is read before its REL_HDR2.  */
6506           rel_hdr = &elf_section_data (input_section)->rel_hdr;
6507           if ((size_t) (rel - relocs)
6508               >= (rel_hdr->sh_size / rel_hdr->sh_entsize
6509                   * bed->s->int_rels_per_ext_rel))
6510             rel_hdr = elf_section_data (input_section)->rel_hdr2;
6511           if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6512             {
6513               /* Note that this is a REL relocation.  */
6514               rela_relocation_p = false;
6515
6516               /* Get the addend, which is stored in the input file.  */
6517               addend = mips_elf_obtain_contents (howto,
6518                                                  rel,
6519                                                  input_bfd,
6520                                                  contents);
6521               addend &= howto->src_mask;
6522
6523               /* For some kinds of relocations, the ADDEND is a
6524                  combination of the addend stored in two different
6525                  relocations.   */
6526               if (r_type == R_MIPS_HI16
6527                   || (r_type == R_MIPS_GOT16
6528                       && mips_elf_local_relocation_p (input_bfd, rel,
6529                                                       local_sections)))
6530                 {
6531                   bfd_vma l;
6532                   const Elf_Internal_Rela *lo16_relocation;
6533                   reloc_howto_type *lo16_howto;
6534
6535                   /* The combined value is the sum of the HI16 addend,
6536                      left-shifted by sixteen bits, and the LO16
6537                      addend, sign extended.  (Usually, the code does
6538                      a `lui' of the HI16 value, and then an `addiu' of
6539                      the LO16 value.)
6540
6541                      Scan ahead to find a matching R_MIPS_LO16
6542                      relocation.  */
6543                   lo16_relocation
6544                     = mips_elf_next_lo16_relocation (rel, relend);
6545                   if (lo16_relocation == NULL)
6546                     return false;
6547
6548                   /* Obtain the addend kept there.  */
6549                   lo16_howto = mips_rtype_to_howto (R_MIPS_LO16);
6550                   l = mips_elf_obtain_contents (lo16_howto,
6551                                                 lo16_relocation,
6552                                                 input_bfd, contents);
6553                   l &= lo16_howto->src_mask;
6554                   l = mips_elf_sign_extend (l, 16);
6555
6556                   /* Save the high-order bit for later.  When we
6557                      encounter the R_MIPS_LO16 relocation we will need
6558                      them again.  */
6559                   addend <<= 16;
6560                   last_hi16_addend = addend;
6561                   last_hi16_addend_valid_p = true;
6562
6563                   /* Compute the combined addend.  */
6564                   addend += l;
6565                 }
6566               else if (r_type == R_MIPS_LO16)
6567                 {
6568                   /* Used the saved HI16 addend.  */
6569                   if (!last_hi16_addend_valid_p)
6570                     {
6571                       bfd_set_error (bfd_error_bad_value);
6572                       return false;
6573                     }
6574                   addend |= last_hi16_addend;
6575                 }
6576               else if (r_type == R_MIPS16_GPREL)
6577                 {
6578                   /* The addend is scrambled in the object file.  See
6579                      mips_elf_perform_relocation for details on the
6580                      format.  */
6581                   addend = (((addend & 0x1f0000) >> 5)
6582                             | ((addend & 0x7e00000) >> 16)
6583                             | (addend & 0x1f));
6584                 }
6585             }
6586           else
6587             addend = rel->r_addend;
6588         }
6589
6590       if (info->relocateable)
6591         {
6592           Elf_Internal_Sym *sym;
6593           unsigned long r_symndx;
6594
6595           /* Since we're just relocating, all we need to do is copy
6596              the relocations back out to the object file, unless
6597              they're against a section symbol, in which case we need
6598              to adjust by the section offset, or unless they're GP
6599              relative in which case we need to adjust by the amount
6600              that we're adjusting GP in this relocateable object.  */
6601
6602           if (!mips_elf_local_relocation_p (input_bfd, rel, local_sections))
6603             /* There's nothing to do for non-local relocations.  */
6604             continue;
6605
6606           if (r_type == R_MIPS16_GPREL
6607               || r_type == R_MIPS_GPREL16
6608               || r_type == R_MIPS_GPREL32)
6609             addend -= (_bfd_get_gp_value (output_bfd)
6610                        - _bfd_get_gp_value (input_bfd));
6611           else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26)
6612             /* The addend is stored without its two least
6613                significant bits (which are always zero.)  In a
6614                non-relocateable link, calculate_relocation will do
6615                this shift; here, we must do it ourselves.  */
6616             addend <<= 2;
6617
6618           r_symndx = ELF32_R_SYM (rel->r_info);
6619           sym = local_syms + r_symndx;
6620           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6621             /* Adjust the addend appropriately.  */
6622             addend += local_sections[r_symndx]->output_offset;
6623
6624           /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6625              then we only want to write out the high-order 16 bits.
6626              The subsequent R_MIPS_LO16 will handle the low-order bits.  */
6627           if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16)
6628             addend = mips_elf_high (addend);
6629           /* If the relocation is for an R_MIPS_26 relocation, then
6630              the two low-order bits are not stored in the object file;
6631              they are implicitly zero.  */
6632           else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26)
6633             addend >>= 2;
6634
6635           if (rela_relocation_p)
6636             /* If this is a RELA relocation, just update the addend.
6637                We have to cast away constness for REL.  */
6638             rel->r_addend = addend;
6639           else
6640             {
6641               /* Otherwise, we have to write the value back out.  Note
6642                  that we use the source mask, rather than the
6643                  destination mask because the place to which we are
6644                  writing will be source of the addend in the final
6645                  link.  */
6646               addend &= howto->src_mask;
6647               if (!mips_elf_perform_relocation (info, howto, rel, addend,
6648                                                 input_bfd,  input_section,
6649                                                 contents, false))
6650                 return false;
6651             }
6652
6653           /* Go on to the next relocation.  */
6654           continue;
6655         }
6656
6657       /* In the N32 and 64-bit ABIs there may be multiple consecutive
6658          relocations for the same offset.  In that case we are
6659          supposed to treat the output of each relocation as the addend
6660          for the next.  */
6661       if (rel + 1 < relend
6662           && rel->r_offset == rel[1].r_offset
6663           && ELF32_R_TYPE (rel[1].r_info) != R_MIPS_NONE)
6664         use_saved_addend_p = true;
6665       else
6666         use_saved_addend_p = false;
6667
6668       /* Figure out what value we are supposed to relocate.  */
6669       switch (mips_elf_calculate_relocation (output_bfd,
6670                                              input_bfd,
6671                                              input_section,
6672                                              info,
6673                                              rel,
6674                                              addend,
6675                                              howto,
6676                                              local_syms,
6677                                              local_sections,
6678                                              &value,
6679                                              &name,
6680                                              &require_jalx))
6681         {
6682         case bfd_reloc_continue:
6683           /* There's nothing to do.  */
6684           continue;
6685
6686         case bfd_reloc_undefined:
6687           /* mips_elf_calculate_relocation already called the
6688              undefined_symbol callback.  There's no real point in
6689              trying to perform the relocation at this point, so we
6690              just skip ahead to the next relocation.  */
6691           continue;
6692
6693         case bfd_reloc_notsupported:
6694           abort ();
6695           break;
6696
6697         case bfd_reloc_overflow:
6698           if (use_saved_addend_p)
6699             /* Ignore overflow until we reach the last relocation for
6700                a given location.  */
6701             ;
6702           else
6703             {
6704               BFD_ASSERT (name != NULL);
6705               if (! ((*info->callbacks->reloc_overflow)
6706                      (info, name, howto->name, (bfd_vma) 0,
6707                       input_bfd, input_section, rel->r_offset)))
6708                 return false;
6709             }
6710           break;
6711
6712         case bfd_reloc_ok:
6713           break;
6714
6715         default:
6716           abort ();
6717           break;
6718         }
6719
6720       /* If we've got another relocation for the address, keep going
6721          until we reach the last one.  */
6722       if (use_saved_addend_p)
6723         {
6724           addend = value;
6725           continue;
6726         }
6727
6728       if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
6729         /* See the comment above about using R_MIPS_64 in the 32-bit
6730            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
6731            that calculated the right value.  Now, however, we
6732            sign-extend the 32-bit result to 64-bits, and store it as a
6733            64-bit value.  We are especially generous here in that we
6734            go to extreme lengths to support this usage on systems with
6735            only a 32-bit VMA.  */
6736         {
6737 #ifdef BFD64
6738           /* Just sign-extend the value, and then fall through to the
6739              normal case, using the R_MIPS_64 howto.  That will store
6740              the 64-bit value into a 64-bit area.  */
6741           value = mips_elf_sign_extend (value, 64);
6742           howto = elf_mips_howto_table + R_MIPS_64;
6743 #else /* !BFD64 */
6744           /* In the 32-bit VMA case, we must handle sign-extension and
6745              endianness manually.  */
6746           bfd_vma sign_bits;
6747           bfd_vma low_bits;
6748           bfd_vma high_bits;
6749
6750           if (value & 0x80000000)
6751             sign_bits = 0xffffffff;
6752           else
6753             sign_bits = 0;
6754
6755           /* If only a 32-bit VMA is available do two separate
6756              stores.  */
6757           if (bfd_big_endian (input_bfd))
6758             {
6759               /* Store the sign-bits (which are most significant)
6760                  first.  */
6761               low_bits = sign_bits;
6762               high_bits = value;
6763             }
6764           else
6765             {
6766               low_bits = value;
6767               high_bits = sign_bits;
6768             }
6769           bfd_put_32 (input_bfd, low_bits,
6770                       contents + rel->r_offset);
6771           bfd_put_32 (input_bfd, high_bits,
6772                       contents + rel->r_offset + 4);
6773           continue;
6774 #endif /* !BFD64 */
6775         }
6776
6777       /* Actually perform the relocation.  */
6778       if (!mips_elf_perform_relocation (info, howto, rel, value, input_bfd,
6779                                         input_section, contents,
6780                                         require_jalx))
6781         return false;
6782     }
6783
6784   return true;
6785 }
6786
6787 /* This hook function is called before the linker writes out a global
6788    symbol.  We mark symbols as small common if appropriate.  This is
6789    also where we undo the increment of the value for a mips16 symbol.  */
6790
6791 /*ARGSIGNORED*/
6792 boolean
6793 _bfd_mips_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
6794      bfd *abfd ATTRIBUTE_UNUSED;
6795      struct bfd_link_info *info ATTRIBUTE_UNUSED;
6796      const char *name ATTRIBUTE_UNUSED;
6797      Elf_Internal_Sym *sym;
6798      asection *input_sec;
6799 {
6800   /* If we see a common symbol, which implies a relocatable link, then
6801      if a symbol was small common in an input file, mark it as small
6802      common in the output file.  */
6803   if (sym->st_shndx == SHN_COMMON
6804       && strcmp (input_sec->name, ".scommon") == 0)
6805     sym->st_shndx = SHN_MIPS_SCOMMON;
6806
6807   if (sym->st_other == STO_MIPS16
6808       && (sym->st_value & 1) != 0)
6809     --sym->st_value;
6810
6811   return true;
6812 }
6813 \f
6814 /* Functions for the dynamic linker.  */
6815
6816 /* The name of the dynamic interpreter.  This is put in the .interp
6817    section.  */
6818
6819 #define ELF_DYNAMIC_INTERPRETER(abfd)           \
6820    (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
6821     : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
6822     : "/usr/lib/libc.so.1")
6823
6824 /* Create dynamic sections when linking against a dynamic object.  */
6825
6826 boolean
6827 _bfd_mips_elf_create_dynamic_sections (abfd, info)
6828      bfd *abfd;
6829      struct bfd_link_info *info;
6830 {
6831   struct elf_link_hash_entry *h;
6832   flagword flags;
6833   register asection *s;
6834   const char * const *namep;
6835
6836   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
6837            | SEC_LINKER_CREATED | SEC_READONLY);
6838
6839   /* Mips ABI requests the .dynamic section to be read only.  */
6840   s = bfd_get_section_by_name (abfd, ".dynamic");
6841   if (s != NULL)
6842     {
6843       if (! bfd_set_section_flags (abfd, s, flags))
6844         return false;
6845     }
6846
6847   /* We need to create .got section.  */
6848   if (! mips_elf_create_got_section (abfd, info))
6849     return false;
6850
6851   /* Create the .msym section on IRIX6.  It is used by the dynamic
6852      linker to speed up dynamic relocations, and to avoid computing
6853      the ELF hash for symbols.  */
6854   if (IRIX_COMPAT (abfd) == ict_irix6
6855       && !mips_elf_create_msym_section (abfd))
6856     return false;
6857
6858   /* Create .stub section.  */
6859   if (bfd_get_section_by_name (abfd,
6860                                MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
6861     {
6862       s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
6863       if (s == NULL
6864           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
6865           || ! bfd_set_section_alignment (abfd, s,
6866                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6867         return false;
6868     }
6869
6870   if (IRIX_COMPAT (abfd) == ict_irix5
6871       && !info->shared
6872       && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
6873     {
6874       s = bfd_make_section (abfd, ".rld_map");
6875       if (s == NULL
6876           || ! bfd_set_section_flags (abfd, s, flags & ~SEC_READONLY)
6877           || ! bfd_set_section_alignment (abfd, s,
6878                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6879         return false;
6880     }
6881
6882   /* On IRIX5, we adjust add some additional symbols and change the
6883      alignments of several sections.  There is no ABI documentation
6884      indicating that this is necessary on IRIX6, nor any evidence that
6885      the linker takes such action.  */
6886   if (IRIX_COMPAT (abfd) == ict_irix5)
6887     {
6888       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
6889         {
6890           h = NULL;
6891           if (! (_bfd_generic_link_add_one_symbol
6892                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr,
6893                   (bfd_vma) 0, (const char *) NULL, false,
6894                   get_elf_backend_data (abfd)->collect,
6895                   (struct bfd_link_hash_entry **) &h)))
6896             return false;
6897           h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
6898           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
6899           h->type = STT_SECTION;
6900
6901           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
6902             return false;
6903         }
6904
6905       /* We need to create a .compact_rel section.  */
6906       if (! mips_elf_create_compact_rel_section (abfd, info))
6907         return false;
6908
6909       /* Change aligments of some sections.  */
6910       s = bfd_get_section_by_name (abfd, ".hash");
6911       if (s != NULL)
6912         bfd_set_section_alignment (abfd, s, 4);
6913       s = bfd_get_section_by_name (abfd, ".dynsym");
6914       if (s != NULL)
6915         bfd_set_section_alignment (abfd, s, 4);
6916       s = bfd_get_section_by_name (abfd, ".dynstr");
6917       if (s != NULL)
6918         bfd_set_section_alignment (abfd, s, 4);
6919       s = bfd_get_section_by_name (abfd, ".reginfo");
6920       if (s != NULL)
6921         bfd_set_section_alignment (abfd, s, 4);
6922       s = bfd_get_section_by_name (abfd, ".dynamic");
6923       if (s != NULL)
6924         bfd_set_section_alignment (abfd, s, 4);
6925     }
6926
6927   if (!info->shared)
6928     {
6929       h = NULL;
6930       if (! (_bfd_generic_link_add_one_symbol
6931              (info, abfd, "_DYNAMIC_LINK", BSF_GLOBAL, bfd_abs_section_ptr,
6932               (bfd_vma) 0, (const char *) NULL, false,
6933               get_elf_backend_data (abfd)->collect,
6934               (struct bfd_link_hash_entry **) &h)))
6935         return false;
6936       h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
6937       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
6938       h->type = STT_SECTION;
6939
6940       if (! bfd_elf32_link_record_dynamic_symbol (info, h))
6941         return false;
6942
6943       if (! mips_elf_hash_table (info)->use_rld_obj_head)
6944         {
6945           /* __rld_map is a four byte word located in the .data section
6946              and is filled in by the rtld to contain a pointer to
6947              the _r_debug structure. Its symbol value will be set in
6948              mips_elf_finish_dynamic_symbol.  */
6949           s = bfd_get_section_by_name (abfd, ".rld_map");
6950           BFD_ASSERT (s != NULL);
6951
6952           h = NULL;
6953           if (! (_bfd_generic_link_add_one_symbol
6954                  (info, abfd, "__rld_map", BSF_GLOBAL, s,
6955                   (bfd_vma) 0, (const char *) NULL, false,
6956                   get_elf_backend_data (abfd)->collect,
6957                   (struct bfd_link_hash_entry **) &h)))
6958             return false;
6959           h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
6960           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
6961           h->type = STT_OBJECT;
6962
6963           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
6964             return false;
6965         }
6966     }
6967
6968   return true;
6969 }
6970
6971 /* Create the .compact_rel section.  */
6972
6973 static boolean
6974 mips_elf_create_compact_rel_section (abfd, info)
6975      bfd *abfd;
6976      struct bfd_link_info *info ATTRIBUTE_UNUSED;
6977 {
6978   flagword flags;
6979   register asection *s;
6980
6981   if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
6982     {
6983       flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
6984                | SEC_READONLY);
6985
6986       s = bfd_make_section (abfd, ".compact_rel");
6987       if (s == NULL
6988           || ! bfd_set_section_flags (abfd, s, flags)
6989           || ! bfd_set_section_alignment (abfd, s,
6990                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6991         return false;
6992
6993       s->_raw_size = sizeof (Elf32_External_compact_rel);
6994     }
6995
6996   return true;
6997 }
6998
6999 /* Create the .got section to hold the global offset table. */
7000
7001 static boolean
7002 mips_elf_create_got_section (abfd, info)
7003      bfd *abfd;
7004      struct bfd_link_info *info;
7005 {
7006   flagword flags;
7007   register asection *s;
7008   struct elf_link_hash_entry *h;
7009   struct mips_got_info *g;
7010
7011   /* This function may be called more than once.  */
7012   if (mips_elf_got_section (abfd))
7013     return true;
7014
7015   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7016            | SEC_LINKER_CREATED);
7017
7018   s = bfd_make_section (abfd, ".got");
7019   if (s == NULL
7020       || ! bfd_set_section_flags (abfd, s, flags)
7021       || ! bfd_set_section_alignment (abfd, s, 4))
7022     return false;
7023
7024   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
7025      linker script because we don't want to define the symbol if we
7026      are not creating a global offset table.  */
7027   h = NULL;
7028   if (! (_bfd_generic_link_add_one_symbol
7029          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
7030           (bfd_vma) 0, (const char *) NULL, false,
7031           get_elf_backend_data (abfd)->collect,
7032           (struct bfd_link_hash_entry **) &h)))
7033     return false;
7034   h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
7035   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7036   h->type = STT_OBJECT;
7037
7038   if (info->shared
7039       && ! bfd_elf32_link_record_dynamic_symbol (info, h))
7040     return false;
7041
7042   /* The first several global offset table entries are reserved.  */
7043   s->_raw_size = MIPS_RESERVED_GOTNO * MIPS_ELF_GOT_SIZE (abfd);
7044
7045   g = (struct mips_got_info *) bfd_alloc (abfd,
7046                                           sizeof (struct mips_got_info));
7047   if (g == NULL)
7048     return false;
7049   g->global_gotsym = NULL;
7050   g->local_gotno = MIPS_RESERVED_GOTNO;
7051   g->assigned_gotno = MIPS_RESERVED_GOTNO;
7052   if (elf_section_data (s) == NULL)
7053     {
7054       s->used_by_bfd =
7055         (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
7056       if (elf_section_data (s) == NULL)
7057         return false;
7058     }
7059   elf_section_data (s)->tdata = (PTR) g;
7060   elf_section_data (s)->this_hdr.sh_flags
7061     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
7062
7063   return true;
7064 }
7065
7066 /* Returns the .msym section for ABFD, creating it if it does not
7067    already exist.  Returns NULL to indicate error.  */
7068
7069 static asection *
7070 mips_elf_create_msym_section (abfd)
7071      bfd *abfd;
7072 {
7073   asection *s;
7074
7075   s = bfd_get_section_by_name (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7076   if (!s)
7077     {
7078       s = bfd_make_section (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7079       if (!s
7080           || !bfd_set_section_flags (abfd, s,
7081                                      SEC_ALLOC
7082                                      | SEC_LOAD
7083                                      | SEC_HAS_CONTENTS
7084                                      | SEC_LINKER_CREATED
7085                                      | SEC_READONLY)
7086           || !bfd_set_section_alignment (abfd, s,
7087                                          MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7088         return NULL;
7089     }
7090
7091   return s;
7092 }
7093
7094 /* Add room for N relocations to the .rel.dyn section in ABFD.  */
7095
7096 static void
7097 mips_elf_allocate_dynamic_relocations (abfd, n)
7098      bfd *abfd;
7099      unsigned int n;
7100 {
7101   asection *s;
7102
7103   s = bfd_get_section_by_name (abfd, MIPS_ELF_REL_DYN_SECTION_NAME (abfd));
7104   BFD_ASSERT (s != NULL);
7105
7106   if (s->_raw_size == 0)
7107     {
7108       /* Make room for a null element. */
7109       s->_raw_size += MIPS_ELF_REL_SIZE (abfd);
7110       ++s->reloc_count;
7111     }
7112   s->_raw_size += n * MIPS_ELF_REL_SIZE (abfd);
7113 }
7114
7115 /* Look through the relocs for a section during the first phase, and
7116    allocate space in the global offset table.  */
7117
7118 boolean
7119 _bfd_mips_elf_check_relocs (abfd, info, sec, relocs)
7120      bfd *abfd;
7121      struct bfd_link_info *info;
7122      asection *sec;
7123      const Elf_Internal_Rela *relocs;
7124 {
7125   const char *name;
7126   bfd *dynobj;
7127   Elf_Internal_Shdr *symtab_hdr;
7128   struct elf_link_hash_entry **sym_hashes;
7129   struct mips_got_info *g;
7130   size_t extsymoff;
7131   const Elf_Internal_Rela *rel;
7132   const Elf_Internal_Rela *rel_end;
7133   asection *sgot;
7134   asection *sreloc;
7135   struct elf_backend_data *bed;
7136
7137   if (info->relocateable)
7138     return true;
7139
7140   dynobj = elf_hash_table (info)->dynobj;
7141   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7142   sym_hashes = elf_sym_hashes (abfd);
7143   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7144
7145   /* Check for the mips16 stub sections.  */
7146
7147   name = bfd_get_section_name (abfd, sec);
7148   if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
7149     {
7150       unsigned long r_symndx;
7151
7152       /* Look at the relocation information to figure out which symbol
7153          this is for.  */
7154
7155       r_symndx = ELF32_R_SYM (relocs->r_info);
7156
7157       if (r_symndx < extsymoff
7158           || sym_hashes[r_symndx - extsymoff] == NULL)
7159         {
7160           asection *o;
7161
7162           /* This stub is for a local symbol.  This stub will only be
7163              needed if there is some relocation in this BFD, other
7164              than a 16 bit function call, which refers to this symbol.  */
7165           for (o = abfd->sections; o != NULL; o = o->next)
7166             {
7167               Elf_Internal_Rela *sec_relocs;
7168               const Elf_Internal_Rela *r, *rend;
7169
7170               /* We can ignore stub sections when looking for relocs.  */
7171               if ((o->flags & SEC_RELOC) == 0
7172                   || o->reloc_count == 0
7173                   || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
7174                               sizeof FN_STUB - 1) == 0
7175                   || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
7176                               sizeof CALL_STUB - 1) == 0
7177                   || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
7178                               sizeof CALL_FP_STUB - 1) == 0)
7179                 continue;
7180
7181               sec_relocs = (_bfd_elf32_link_read_relocs
7182                             (abfd, o, (PTR) NULL,
7183                              (Elf_Internal_Rela *) NULL,
7184                              info->keep_memory));
7185               if (sec_relocs == NULL)
7186                 return false;
7187
7188               rend = sec_relocs + o->reloc_count;
7189               for (r = sec_relocs; r < rend; r++)
7190                 if (ELF32_R_SYM (r->r_info) == r_symndx
7191                     && ELF32_R_TYPE (r->r_info) != R_MIPS16_26)
7192                   break;
7193
7194               if (! info->keep_memory)
7195                 free (sec_relocs);
7196
7197               if (r < rend)
7198                 break;
7199             }
7200
7201           if (o == NULL)
7202             {
7203               /* There is no non-call reloc for this stub, so we do
7204                  not need it.  Since this function is called before
7205                  the linker maps input sections to output sections, we
7206                  can easily discard it by setting the SEC_EXCLUDE
7207                  flag.  */
7208               sec->flags |= SEC_EXCLUDE;
7209               return true;
7210             }
7211
7212           /* Record this stub in an array of local symbol stubs for
7213              this BFD. */
7214           if (elf_tdata (abfd)->local_stubs == NULL)
7215             {
7216               unsigned long symcount;
7217               asection **n;
7218
7219               if (elf_bad_symtab (abfd))
7220                 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
7221               else
7222                 symcount = symtab_hdr->sh_info;
7223               n = (asection **) bfd_zalloc (abfd,
7224                                             symcount * sizeof (asection *));
7225               if (n == NULL)
7226                 return false;
7227               elf_tdata (abfd)->local_stubs = n;
7228             }
7229
7230           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7231
7232           /* We don't need to set mips16_stubs_seen in this case.
7233              That flag is used to see whether we need to look through
7234              the global symbol table for stubs.  We don't need to set
7235              it here, because we just have a local stub.  */
7236         }
7237       else
7238         {
7239           struct mips_elf_link_hash_entry *h;
7240
7241           h = ((struct mips_elf_link_hash_entry *)
7242                sym_hashes[r_symndx - extsymoff]);
7243
7244           /* H is the symbol this stub is for.  */
7245
7246           h->fn_stub = sec;
7247           mips_elf_hash_table (info)->mips16_stubs_seen = true;
7248         }
7249     }
7250   else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
7251            || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7252     {
7253       unsigned long r_symndx;
7254       struct mips_elf_link_hash_entry *h;
7255       asection **loc;
7256
7257       /* Look at the relocation information to figure out which symbol
7258          this is for.  */
7259
7260       r_symndx = ELF32_R_SYM (relocs->r_info);
7261
7262       if (r_symndx < extsymoff
7263           || sym_hashes[r_symndx - extsymoff] == NULL)
7264         {
7265           /* This stub was actually built for a static symbol defined
7266              in the same file.  We assume that all static symbols in
7267              mips16 code are themselves mips16, so we can simply
7268              discard this stub.  Since this function is called before
7269              the linker maps input sections to output sections, we can
7270              easily discard it by setting the SEC_EXCLUDE flag.  */
7271           sec->flags |= SEC_EXCLUDE;
7272           return true;
7273         }
7274
7275       h = ((struct mips_elf_link_hash_entry *)
7276            sym_hashes[r_symndx - extsymoff]);
7277
7278       /* H is the symbol this stub is for.  */
7279
7280       if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7281         loc = &h->call_fp_stub;
7282       else
7283         loc = &h->call_stub;
7284
7285       /* If we already have an appropriate stub for this function, we
7286          don't need another one, so we can discard this one.  Since
7287          this function is called before the linker maps input sections
7288          to output sections, we can easily discard it by setting the
7289          SEC_EXCLUDE flag.  We can also discard this section if we
7290          happen to already know that this is a mips16 function; it is
7291          not necessary to check this here, as it is checked later, but
7292          it is slightly faster to check now.  */
7293       if (*loc != NULL || h->root.other == STO_MIPS16)
7294         {
7295           sec->flags |= SEC_EXCLUDE;
7296           return true;
7297         }
7298
7299       *loc = sec;
7300       mips_elf_hash_table (info)->mips16_stubs_seen = true;
7301     }
7302
7303   if (dynobj == NULL)
7304     {
7305       sgot = NULL;
7306       g = NULL;
7307     }
7308   else
7309     {
7310       sgot = mips_elf_got_section (dynobj);
7311       if (sgot == NULL)
7312         g = NULL;
7313       else
7314         {
7315           BFD_ASSERT (elf_section_data (sgot) != NULL);
7316           g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
7317           BFD_ASSERT (g != NULL);
7318         }
7319     }
7320
7321   sreloc = NULL;
7322   bed = get_elf_backend_data (abfd);
7323   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7324   for (rel = relocs; rel < rel_end; ++rel)
7325     {
7326       unsigned long r_symndx;
7327       int r_type;
7328       struct elf_link_hash_entry *h;
7329
7330       r_symndx = ELF32_R_SYM (rel->r_info);
7331       r_type = ELF32_R_TYPE (rel->r_info);
7332
7333       if (r_symndx < extsymoff)
7334         h = NULL;
7335       else
7336         {
7337           h = sym_hashes[r_symndx - extsymoff];
7338
7339           /* This may be an indirect symbol created because of a version.  */
7340           if (h != NULL)
7341             {
7342               while (h->root.type == bfd_link_hash_indirect)
7343                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7344             }
7345         }
7346
7347       /* Some relocs require a global offset table.  */
7348       if (dynobj == NULL || sgot == NULL)
7349         {
7350           switch (r_type)
7351             {
7352             case R_MIPS_GOT16:
7353             case R_MIPS_CALL16:
7354             case R_MIPS_CALL_HI16:
7355             case R_MIPS_CALL_LO16:
7356             case R_MIPS_GOT_HI16:
7357             case R_MIPS_GOT_LO16:
7358             case R_MIPS_GOT_PAGE:
7359             case R_MIPS_GOT_OFST:
7360             case R_MIPS_GOT_DISP:
7361               if (dynobj == NULL)
7362                 elf_hash_table (info)->dynobj = dynobj = abfd;
7363               if (! mips_elf_create_got_section (dynobj, info))
7364                 return false;
7365               g = mips_elf_got_info (dynobj, &sgot);
7366               break;
7367
7368             case R_MIPS_32:
7369             case R_MIPS_REL32:
7370             case R_MIPS_64:
7371               if (dynobj == NULL
7372                   && (info->shared || h != NULL)
7373                   && (sec->flags & SEC_ALLOC) != 0)
7374                 elf_hash_table (info)->dynobj = dynobj = abfd;
7375               break;
7376
7377             default:
7378               break;
7379             }
7380         }
7381
7382       if (!h && (r_type == R_MIPS_CALL_LO16
7383                  || r_type == R_MIPS_GOT_LO16
7384                  || r_type == R_MIPS_GOT_DISP
7385                  || r_type == R_MIPS_GOT16))
7386         {
7387           /* We may need a local GOT entry for this relocation.  We
7388              don't count R_MIPS_GOT_PAGE because we can estimate the
7389              maximum number of pages needed by looking at the size of
7390              the segment.  We don't count R_MIPS_GOT_HI16, or
7391              R_MIPS_CALL_HI16 because these are always followed by an
7392              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
7393
7394              This estimation is very conservative since we can merge
7395              duplicate entries in the GOT.  In order to be less
7396              conservative, we could actually build the GOT here,
7397              rather than in relocate_section.  */
7398           g->local_gotno++;
7399           sgot->_raw_size += MIPS_ELF_GOT_SIZE (dynobj);
7400         }
7401
7402       switch (r_type)
7403         {
7404         case R_MIPS_CALL16:
7405           if (h == NULL)
7406             {
7407               (*_bfd_error_handler)
7408                 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7409                  bfd_get_filename (abfd), (unsigned long) rel->r_offset);
7410               bfd_set_error (bfd_error_bad_value);
7411               return false;
7412             }
7413           /* Fall through.  */
7414
7415         case R_MIPS_CALL_HI16:
7416         case R_MIPS_CALL_LO16:
7417           if (h != NULL)
7418             {
7419               /* This symbol requires a global offset table entry.  */
7420               if (!mips_elf_record_global_got_symbol (h, info, g))
7421                 return false;
7422
7423               /* We need a stub, not a plt entry for the undefined
7424                  function.  But we record it as if it needs plt.  See
7425                  elf_adjust_dynamic_symbol in elflink.h.  */
7426               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
7427               h->type = STT_FUNC;
7428             }
7429           break;
7430
7431         case R_MIPS_GOT16:
7432         case R_MIPS_GOT_HI16:
7433         case R_MIPS_GOT_LO16:
7434         case R_MIPS_GOT_DISP:
7435           /* This symbol requires a global offset table entry.  */
7436           if (h && !mips_elf_record_global_got_symbol (h, info, g))
7437             return false;
7438           break;
7439
7440         case R_MIPS_32:
7441         case R_MIPS_REL32:
7442         case R_MIPS_64:
7443           if ((info->shared || h != NULL)
7444               && (sec->flags & SEC_ALLOC) != 0)
7445             {
7446               if (sreloc == NULL)
7447                 {
7448                   const char *name = MIPS_ELF_REL_DYN_SECTION_NAME (dynobj);
7449
7450                   sreloc = bfd_get_section_by_name (dynobj, name);
7451                   if (sreloc == NULL)
7452                     {
7453                       sreloc = bfd_make_section (dynobj, name);
7454                       if (sreloc == NULL
7455                           || ! bfd_set_section_flags (dynobj, sreloc,
7456                                                       (SEC_ALLOC
7457                                                        | SEC_LOAD
7458                                                        | SEC_HAS_CONTENTS
7459                                                        | SEC_IN_MEMORY
7460                                                        | SEC_LINKER_CREATED
7461                                                        | SEC_READONLY))
7462                           || ! bfd_set_section_alignment (dynobj, sreloc,
7463                                                           4))
7464                         return false;
7465                     }
7466                 }
7467               if (info->shared)
7468                 /* When creating a shared object, we must copy these
7469                    reloc types into the output file as R_MIPS_REL32
7470                    relocs.  We make room for this reloc in the
7471                    .rel.dyn reloc section.  */
7472                 mips_elf_allocate_dynamic_relocations (dynobj, 1);
7473               else
7474                 {
7475                   struct mips_elf_link_hash_entry *hmips;
7476
7477                   /* We only need to copy this reloc if the symbol is
7478                      defined in a dynamic object.  */
7479                   hmips = (struct mips_elf_link_hash_entry *) h;
7480                   ++hmips->possibly_dynamic_relocs;
7481                 }
7482
7483               /* Even though we don't directly need a GOT entry for
7484                  this symbol, a symbol must have a dynamic symbol
7485                  table index greater that DT_GOTSYM if there are
7486                  dynamic relocations against it.  */
7487               if (!mips_elf_record_global_got_symbol (h, info, g))
7488                 return false;
7489             }
7490
7491           if (SGI_COMPAT (dynobj))
7492             mips_elf_hash_table (info)->compact_rel_size +=
7493               sizeof (Elf32_External_crinfo);
7494           break;
7495
7496         case R_MIPS_26:
7497         case R_MIPS_GPREL16:
7498         case R_MIPS_LITERAL:
7499         case R_MIPS_GPREL32:
7500           if (SGI_COMPAT (dynobj))
7501             mips_elf_hash_table (info)->compact_rel_size +=
7502               sizeof (Elf32_External_crinfo);
7503           break;
7504
7505           /* This relocation describes the C++ object vtable hierarchy.
7506              Reconstruct it for later use during GC.  */
7507         case R_MIPS_GNU_VTINHERIT:
7508           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7509             return false;
7510           break;
7511
7512           /* This relocation describes which C++ vtable entries are actually
7513              used.  Record for later use during GC.  */
7514         case R_MIPS_GNU_VTENTRY:
7515           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7516             return false;
7517           break;
7518
7519         default:
7520           break;
7521         }
7522
7523       /* If this reloc is not a 16 bit call, and it has a global
7524          symbol, then we will need the fn_stub if there is one.
7525          References from a stub section do not count. */
7526       if (h != NULL
7527           && r_type != R_MIPS16_26
7528           && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
7529                       sizeof FN_STUB - 1) != 0
7530           && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
7531                       sizeof CALL_STUB - 1) != 0
7532           && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
7533                       sizeof CALL_FP_STUB - 1) != 0)
7534         {
7535           struct mips_elf_link_hash_entry *mh;
7536
7537           mh = (struct mips_elf_link_hash_entry *) h;
7538           mh->need_fn_stub = true;
7539         }
7540     }
7541
7542   return true;
7543 }
7544
7545 /* Return the section that should be marked against GC for a given
7546    relocation.  */
7547
7548 asection *
7549 _bfd_mips_elf_gc_mark_hook (abfd, info, rel, h, sym)
7550      bfd *abfd;
7551      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7552      Elf_Internal_Rela *rel;
7553      struct elf_link_hash_entry *h;
7554      Elf_Internal_Sym *sym;
7555 {
7556   /* ??? Do mips16 stub sections need to be handled special?  */
7557
7558   if (h != NULL)
7559     {
7560       switch (ELF32_R_TYPE (rel->r_info))
7561         {
7562         case R_MIPS_GNU_VTINHERIT:
7563         case R_MIPS_GNU_VTENTRY:
7564           break;
7565
7566         default:
7567           switch (h->root.type)
7568             {
7569             case bfd_link_hash_defined:
7570             case bfd_link_hash_defweak:
7571               return h->root.u.def.section;
7572
7573             case bfd_link_hash_common:
7574               return h->root.u.c.p->section;
7575
7576             default:
7577               break;
7578             }
7579         }
7580     }
7581   else
7582     {
7583       if (!(elf_bad_symtab (abfd)
7584             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7585           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
7586                 && sym->st_shndx != SHN_COMMON))
7587         {
7588           return bfd_section_from_elf_index (abfd, sym->st_shndx);
7589         }
7590     }
7591
7592   return NULL;
7593 }
7594
7595 /* Update the got entry reference counts for the section being removed.  */
7596
7597 boolean
7598 _bfd_mips_elf_gc_sweep_hook (abfd, info, sec, relocs)
7599      bfd *abfd ATTRIBUTE_UNUSED;
7600      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7601      asection *sec ATTRIBUTE_UNUSED;
7602      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
7603 {
7604 #if 0
7605   Elf_Internal_Shdr *symtab_hdr;
7606   struct elf_link_hash_entry **sym_hashes;
7607   bfd_signed_vma *local_got_refcounts;
7608   const Elf_Internal_Rela *rel, *relend;
7609   unsigned long r_symndx;
7610   struct elf_link_hash_entry *h;
7611
7612   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7613   sym_hashes = elf_sym_hashes (abfd);
7614   local_got_refcounts = elf_local_got_refcounts (abfd);
7615
7616   relend = relocs + sec->reloc_count;
7617   for (rel = relocs; rel < relend; rel++)
7618     switch (ELF32_R_TYPE (rel->r_info))
7619       {
7620       case R_MIPS_GOT16:
7621       case R_MIPS_CALL16:
7622       case R_MIPS_CALL_HI16:
7623       case R_MIPS_CALL_LO16:
7624       case R_MIPS_GOT_HI16:
7625       case R_MIPS_GOT_LO16:
7626         /* ??? It would seem that the existing MIPS code does no sort
7627            of reference counting or whatnot on its GOT and PLT entries,
7628            so it is not possible to garbage collect them at this time.  */
7629         break;
7630
7631       default:
7632         break;
7633       }
7634 #endif
7635
7636   return true;
7637 }
7638
7639
7640 /* Adjust a symbol defined by a dynamic object and referenced by a
7641    regular object.  The current definition is in some section of the
7642    dynamic object, but we're not including those sections.  We have to
7643    change the definition to something the rest of the link can
7644    understand.  */
7645
7646 boolean
7647 _bfd_mips_elf_adjust_dynamic_symbol (info, h)
7648      struct bfd_link_info *info;
7649      struct elf_link_hash_entry *h;
7650 {
7651   bfd *dynobj;
7652   struct mips_elf_link_hash_entry *hmips;
7653   asection *s;
7654
7655   dynobj = elf_hash_table (info)->dynobj;
7656
7657   /* Make sure we know what is going on here.  */
7658   BFD_ASSERT (dynobj != NULL
7659               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
7660                   || h->weakdef != NULL
7661                   || ((h->elf_link_hash_flags
7662                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
7663                       && (h->elf_link_hash_flags
7664                           & ELF_LINK_HASH_REF_REGULAR) != 0
7665                       && (h->elf_link_hash_flags
7666                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
7667
7668   /* If this symbol is defined in a dynamic object, we need to copy
7669      any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7670      file.  */
7671   hmips = (struct mips_elf_link_hash_entry *) h;
7672   if (! info->relocateable
7673       && hmips->possibly_dynamic_relocs != 0
7674       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
7675     mips_elf_allocate_dynamic_relocations (dynobj,
7676                                            hmips->possibly_dynamic_relocs);
7677
7678   /* For a function, create a stub, if needed. */
7679   if (h->type == STT_FUNC
7680       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
7681     {
7682       if (! elf_hash_table (info)->dynamic_sections_created)
7683         return true;
7684
7685       /* If this symbol is not defined in a regular file, then set
7686          the symbol to the stub location.  This is required to make
7687          function pointers compare as equal between the normal
7688          executable and the shared library.  */
7689       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
7690         {
7691           /* We need .stub section.  */
7692           s = bfd_get_section_by_name (dynobj,
7693                                        MIPS_ELF_STUB_SECTION_NAME (dynobj));
7694           BFD_ASSERT (s != NULL);
7695
7696           h->root.u.def.section = s;
7697           h->root.u.def.value = s->_raw_size;
7698
7699           /* XXX Write this stub address somewhere.  */
7700           h->plt.offset = s->_raw_size;
7701
7702           /* Make room for this stub code.  */
7703           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
7704
7705           /* The last half word of the stub will be filled with the index
7706              of this symbol in .dynsym section.  */
7707           return true;
7708         }
7709     }
7710
7711   /* If this is a weak symbol, and there is a real definition, the
7712      processor independent code will have arranged for us to see the
7713      real definition first, and we can just use the same value.  */
7714   if (h->weakdef != NULL)
7715     {
7716       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
7717                   || h->weakdef->root.type == bfd_link_hash_defweak);
7718       h->root.u.def.section = h->weakdef->root.u.def.section;
7719       h->root.u.def.value = h->weakdef->root.u.def.value;
7720       return true;
7721     }
7722
7723   /* This is a reference to a symbol defined by a dynamic object which
7724      is not a function.  */
7725
7726   return true;
7727 }
7728
7729 /* This function is called after all the input files have been read,
7730    and the input sections have been assigned to output sections.  We
7731    check for any mips16 stub sections that we can discard.  */
7732
7733 static boolean mips_elf_check_mips16_stubs
7734   PARAMS ((struct mips_elf_link_hash_entry *, PTR));
7735
7736 boolean
7737 _bfd_mips_elf_always_size_sections (output_bfd, info)
7738      bfd *output_bfd;
7739      struct bfd_link_info *info;
7740 {
7741   asection *ri;
7742
7743   /* The .reginfo section has a fixed size.  */
7744   ri = bfd_get_section_by_name (output_bfd, ".reginfo");
7745   if (ri != NULL)
7746     bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
7747
7748   if (info->relocateable
7749       || ! mips_elf_hash_table (info)->mips16_stubs_seen)
7750     return true;
7751
7752   mips_elf_link_hash_traverse (mips_elf_hash_table (info),
7753                                mips_elf_check_mips16_stubs,
7754                                (PTR) NULL);
7755
7756   return true;
7757 }
7758
7759 /* Check the mips16 stubs for a particular symbol, and see if we can
7760    discard them.  */
7761
7762 /*ARGSUSED*/
7763 static boolean
7764 mips_elf_check_mips16_stubs (h, data)
7765      struct mips_elf_link_hash_entry *h;
7766      PTR data ATTRIBUTE_UNUSED;
7767 {
7768   if (h->fn_stub != NULL
7769       && ! h->need_fn_stub)
7770     {
7771       /* We don't need the fn_stub; the only references to this symbol
7772          are 16 bit calls.  Clobber the size to 0 to prevent it from
7773          being included in the link.  */
7774       h->fn_stub->_raw_size = 0;
7775       h->fn_stub->_cooked_size = 0;
7776       h->fn_stub->flags &= ~ SEC_RELOC;
7777       h->fn_stub->reloc_count = 0;
7778       h->fn_stub->flags |= SEC_EXCLUDE;
7779     }
7780
7781   if (h->call_stub != NULL
7782       && h->root.other == STO_MIPS16)
7783     {
7784       /* We don't need the call_stub; this is a 16 bit function, so
7785          calls from other 16 bit functions are OK.  Clobber the size
7786          to 0 to prevent it from being included in the link.  */
7787       h->call_stub->_raw_size = 0;
7788       h->call_stub->_cooked_size = 0;
7789       h->call_stub->flags &= ~ SEC_RELOC;
7790       h->call_stub->reloc_count = 0;
7791       h->call_stub->flags |= SEC_EXCLUDE;
7792     }
7793
7794   if (h->call_fp_stub != NULL
7795       && h->root.other == STO_MIPS16)
7796     {
7797       /* We don't need the call_stub; this is a 16 bit function, so
7798          calls from other 16 bit functions are OK.  Clobber the size
7799          to 0 to prevent it from being included in the link.  */
7800       h->call_fp_stub->_raw_size = 0;
7801       h->call_fp_stub->_cooked_size = 0;
7802       h->call_fp_stub->flags &= ~ SEC_RELOC;
7803       h->call_fp_stub->reloc_count = 0;
7804       h->call_fp_stub->flags |= SEC_EXCLUDE;
7805     }
7806
7807   return true;
7808 }
7809
7810 /* Set the sizes of the dynamic sections.  */
7811
7812 boolean
7813 _bfd_mips_elf_size_dynamic_sections (output_bfd, info)
7814      bfd *output_bfd;
7815      struct bfd_link_info *info;
7816 {
7817   bfd *dynobj;
7818   asection *s;
7819   boolean reltext;
7820   struct mips_got_info *g = NULL;
7821
7822   dynobj = elf_hash_table (info)->dynobj;
7823   BFD_ASSERT (dynobj != NULL);
7824
7825   if (elf_hash_table (info)->dynamic_sections_created)
7826     {
7827       /* Set the contents of the .interp section to the interpreter.  */
7828       if (! info->shared)
7829         {
7830           s = bfd_get_section_by_name (dynobj, ".interp");
7831           BFD_ASSERT (s != NULL);
7832           s->_raw_size
7833             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
7834           s->contents
7835             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
7836         }
7837     }
7838
7839   /* The check_relocs and adjust_dynamic_symbol entry points have
7840      determined the sizes of the various dynamic sections.  Allocate
7841      memory for them.  */
7842   reltext = false;
7843   for (s = dynobj->sections; s != NULL; s = s->next)
7844     {
7845       const char *name;
7846       boolean strip;
7847
7848       /* It's OK to base decisions on the section name, because none
7849          of the dynobj section names depend upon the input files.  */
7850       name = bfd_get_section_name (dynobj, s);
7851
7852       if ((s->flags & SEC_LINKER_CREATED) == 0)
7853         continue;
7854
7855       strip = false;
7856
7857       if (strncmp (name, ".rel", 4) == 0)
7858         {
7859           if (s->_raw_size == 0)
7860             {
7861               /* We only strip the section if the output section name
7862                  has the same name.  Otherwise, there might be several
7863                  input sections for this output section.  FIXME: This
7864                  code is probably not needed these days anyhow, since
7865                  the linker now does not create empty output sections.  */
7866               if (s->output_section != NULL
7867                   && strcmp (name,
7868                              bfd_get_section_name (s->output_section->owner,
7869                                                    s->output_section)) == 0)
7870                 strip = true;
7871             }
7872           else
7873             {
7874               const char *outname;
7875               asection *target;
7876
7877               /* If this relocation section applies to a read only
7878                  section, then we probably need a DT_TEXTREL entry.
7879                  If the relocation section is .rel.dyn, we always
7880                  assert a DT_TEXTREL entry rather than testing whether
7881                  there exists a relocation to a read only section or
7882                  not.  */
7883               outname = bfd_get_section_name (output_bfd,
7884                                               s->output_section);
7885               target = bfd_get_section_by_name (output_bfd, outname + 4);
7886               if ((target != NULL
7887                    && (target->flags & SEC_READONLY) != 0
7888                    && (target->flags & SEC_ALLOC) != 0)
7889                   || strcmp (outname,
7890                              MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) == 0)
7891                 reltext = true;
7892
7893               /* We use the reloc_count field as a counter if we need
7894                  to copy relocs into the output file.  */
7895               if (strcmp (name,
7896                           MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) != 0)
7897                 s->reloc_count = 0;
7898             }
7899         }
7900       else if (strncmp (name, ".got", 4) == 0)
7901         {
7902           int i;
7903           bfd_size_type loadable_size = 0;
7904           bfd_size_type local_gotno;
7905           struct _bfd *sub;
7906
7907           BFD_ASSERT (elf_section_data (s) != NULL);
7908           g = (struct mips_got_info *) elf_section_data (s)->tdata;
7909           BFD_ASSERT (g != NULL);
7910
7911           /* Calculate the total loadable size of the output.  That
7912              will give us the maximum number of GOT_PAGE entries
7913              required.  */
7914           for (sub = info->input_bfds; sub; sub = sub->link_next)
7915             {
7916               asection *subsection;
7917
7918               for (subsection = sub->sections;
7919                    subsection;
7920                    subsection = subsection->next)
7921                 {
7922                   if ((subsection->flags & SEC_ALLOC) == 0)
7923                     continue;
7924                   loadable_size += (subsection->_raw_size + 0xf) & ~0xf;
7925                 }
7926             }
7927           loadable_size += MIPS_FUNCTION_STUB_SIZE;
7928
7929           /* Assume there are two loadable segments consisting of
7930              contiguous sections.  Is 5 enough? */
7931           local_gotno = (loadable_size >> 16) + 5;
7932           g->local_gotno += local_gotno;
7933           s->_raw_size += local_gotno * MIPS_ELF_GOT_SIZE (dynobj);
7934
7935           /* There has to be a global GOT entry for every symbol with
7936              a dynamic symbol table index of DT_MIPS_GOTSYM or
7937              higher.  Therefore, it make sense to put those symbols
7938              that need GOT entries at the end of the symbol table.  We
7939              do that here.  */
7940           if (!mips_elf_sort_hash_table (info, 1))
7941             return false;
7942
7943           if (g->global_gotsym != NULL)
7944             i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
7945           else
7946             /* If there are no global symbols, or none requiring
7947                relocations, then GLOBAL_GOTSYM will be NULL.  */
7948             i = 0;
7949           g->global_gotno = i;
7950           s->_raw_size += i * MIPS_ELF_GOT_SIZE (dynobj);
7951         }
7952       else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
7953         {
7954           /* Irix rld assumes that the function stub isn't at the end
7955              of .text section. So put a dummy. XXX  */
7956           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
7957         }
7958       else if (! info->shared
7959                && ! mips_elf_hash_table (info)->use_rld_obj_head
7960                && strncmp (name, ".rld_map", 8) == 0)
7961         {
7962           /* We add a room for __rld_map. It will be filled in by the
7963              rtld to contain a pointer to the _r_debug structure.  */
7964           s->_raw_size += 4;
7965         }
7966       else if (SGI_COMPAT (output_bfd)
7967                && strncmp (name, ".compact_rel", 12) == 0)
7968         s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
7969       else if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (output_bfd))
7970                == 0)
7971         s->_raw_size = (sizeof (Elf32_External_Msym)
7972                         * (elf_hash_table (info)->dynsymcount
7973                            + bfd_count_sections (output_bfd)));
7974       else if (strncmp (name, ".init", 5) != 0)
7975         {
7976           /* It's not one of our sections, so don't allocate space.  */
7977           continue;
7978         }
7979
7980       if (strip)
7981         {
7982           _bfd_strip_section_from_output (s);
7983           continue;
7984         }
7985
7986       /* Allocate memory for the section contents.  */
7987       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
7988       if (s->contents == NULL && s->_raw_size != 0)
7989         {
7990           bfd_set_error (bfd_error_no_memory);
7991           return false;
7992         }
7993     }
7994
7995   if (elf_hash_table (info)->dynamic_sections_created)
7996     {
7997       /* Add some entries to the .dynamic section.  We fill in the
7998          values later, in elf_mips_finish_dynamic_sections, but we
7999          must add the entries now so that we get the correct size for
8000          the .dynamic section.  The DT_DEBUG entry is filled in by the
8001          dynamic linker and used by the debugger.  */
8002       if (! info->shared)
8003         {
8004           if (SGI_COMPAT (output_bfd))
8005             {
8006               /* SGI object has the equivalence of DT_DEBUG in the
8007                  DT_MIPS_RLD_MAP entry.  */
8008               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
8009                 return false;
8010             }
8011           else
8012             if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
8013               return false;
8014         }
8015
8016       if (reltext)
8017         {
8018           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
8019             return false;
8020         }
8021
8022       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
8023         return false;
8024
8025       if (bfd_get_section_by_name (dynobj,
8026                                    MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)))
8027         {
8028           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
8029             return false;
8030
8031           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
8032             return false;
8033
8034           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
8035             return false;
8036         }
8037
8038       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICTNO, 0))
8039         return false;
8040
8041       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLISTNO, 0))
8042         return false;
8043
8044       if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
8045         {
8046           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICT, 0))
8047             return false;
8048
8049           s = bfd_get_section_by_name (dynobj, ".liblist");
8050           BFD_ASSERT (s != NULL);
8051
8052           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLIST, 0))
8053             return false;
8054         }
8055
8056       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
8057         return false;
8058
8059       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
8060         return false;
8061
8062 #if 0
8063       /* Time stamps in executable files are a bad idea.  */
8064       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
8065         return false;
8066 #endif
8067
8068 #if 0 /* FIXME  */
8069       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
8070         return false;
8071 #endif
8072
8073 #if 0 /* FIXME  */
8074       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
8075         return false;
8076 #endif
8077
8078       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
8079         return false;
8080
8081       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
8082         return false;
8083
8084       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
8085         return false;
8086
8087       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
8088         return false;
8089
8090       if (g != NULL && g->global_gotsym != NULL
8091           && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
8092         return false;
8093
8094       if (IRIX_COMPAT (dynobj) == ict_irix5
8095           && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
8096         return false;
8097
8098       if (IRIX_COMPAT (dynobj) == ict_irix6
8099           && (bfd_get_section_by_name
8100               (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
8101           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
8102         return false;
8103
8104       if (bfd_get_section_by_name (dynobj,
8105                                    MIPS_ELF_MSYM_SECTION_NAME (dynobj))
8106           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_MSYM, 0))
8107         return false;
8108     }
8109
8110   return true;
8111 }
8112
8113 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8114    adjust it appropriately now.  */
8115
8116 static void
8117 mips_elf_irix6_finish_dynamic_symbol (abfd, name, sym)
8118      bfd *abfd ATTRIBUTE_UNUSED;
8119      const char *name;
8120      Elf_Internal_Sym *sym;
8121 {
8122   /* The linker script takes care of providing names and values for
8123      these, but we must place them into the right sections.  */
8124   static const char* const text_section_symbols[] = {
8125     "_ftext",
8126     "_etext",
8127     "__dso_displacement",
8128     "__elf_header",
8129     "__program_header_table",
8130     NULL
8131   };
8132
8133   static const char* const data_section_symbols[] = {
8134     "_fdata",
8135     "_edata",
8136     "_end",
8137     "_fbss",
8138     NULL
8139   };
8140
8141   const char* const *p;
8142   int i;
8143
8144   for (i = 0; i < 2; ++i)
8145     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
8146          *p;
8147          ++p)
8148       if (strcmp (*p, name) == 0)
8149         {
8150           /* All of these symbols are given type STT_SECTION by the
8151              IRIX6 linker.  */
8152           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8153
8154           /* The IRIX linker puts these symbols in special sections.  */
8155           if (i == 0)
8156             sym->st_shndx = SHN_MIPS_TEXT;
8157           else
8158             sym->st_shndx = SHN_MIPS_DATA;
8159
8160           break;
8161         }
8162 }
8163
8164 /* Finish up dynamic symbol handling.  We set the contents of various
8165    dynamic sections here.  */
8166
8167 boolean
8168 _bfd_mips_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
8169      bfd *output_bfd;
8170      struct bfd_link_info *info;
8171      struct elf_link_hash_entry *h;
8172      Elf_Internal_Sym *sym;
8173 {
8174   bfd *dynobj;
8175   bfd_vma gval;
8176   asection *sgot;
8177   asection *smsym;
8178   struct mips_got_info *g;
8179   const char *name;
8180   struct mips_elf_link_hash_entry *mh;
8181
8182   dynobj = elf_hash_table (info)->dynobj;
8183   gval = sym->st_value;
8184   mh = (struct mips_elf_link_hash_entry *) h;
8185
8186   if (h->plt.offset != (bfd_vma) -1)
8187     {
8188       asection *s;
8189       bfd_byte *p;
8190       bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
8191
8192       /* This symbol has a stub.  Set it up.  */
8193
8194       BFD_ASSERT (h->dynindx != -1);
8195
8196       s = bfd_get_section_by_name (dynobj,
8197                                    MIPS_ELF_STUB_SECTION_NAME (dynobj));
8198       BFD_ASSERT (s != NULL);
8199
8200       /* Fill the stub.  */
8201       p = stub;
8202       bfd_put_32 (output_bfd, STUB_LW(output_bfd), p);
8203       p += 4;
8204       bfd_put_32 (output_bfd, STUB_MOVE, p);
8205       p += 4;
8206
8207       /* FIXME: Can h->dynindex be more than 64K?  */
8208       if (h->dynindx & 0xffff0000)
8209         return false;
8210
8211       bfd_put_32 (output_bfd, STUB_JALR, p);
8212       p += 4;
8213       bfd_put_32 (output_bfd, STUB_LI16 + h->dynindx, p);
8214
8215       BFD_ASSERT (h->plt.offset <= s->_raw_size);
8216       memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
8217
8218       /* Mark the symbol as undefined.  plt.offset != -1 occurs
8219          only for the referenced symbol.  */
8220       sym->st_shndx = SHN_UNDEF;
8221
8222       /* The run-time linker uses the st_value field of the symbol
8223          to reset the global offset table entry for this external
8224          to its stub address when unlinking a shared object.  */
8225       gval = s->output_section->vma + s->output_offset + h->plt.offset;
8226       sym->st_value = gval;
8227     }
8228
8229   BFD_ASSERT (h->dynindx != -1);
8230
8231   sgot = mips_elf_got_section (dynobj);
8232   BFD_ASSERT (sgot != NULL);
8233   BFD_ASSERT (elf_section_data (sgot) != NULL);
8234   g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8235   BFD_ASSERT (g != NULL);
8236
8237   /* Run through the global symbol table, creating GOT entries for all
8238      the symbols that need them.  */
8239   if (g->global_gotsym != NULL
8240       && h->dynindx >= g->global_gotsym->dynindx)
8241     {
8242       bfd_vma offset;
8243       bfd_vma value;
8244
8245       if (sym->st_value)
8246         value = sym->st_value;
8247       else
8248         /* For an entity defined in a shared object, this will be
8249            NULL.  (For functions in shared objects for
8250            which we have created stubs, ST_VALUE will be non-NULL.
8251            That's because such the functions are now no longer defined
8252            in a shared object.)  */
8253         value = h->root.u.def.value;
8254
8255       offset = mips_elf_global_got_index (dynobj, h);
8256       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
8257     }
8258
8259   /* Create a .msym entry, if appropriate.  */
8260   smsym = bfd_get_section_by_name (dynobj,
8261                                    MIPS_ELF_MSYM_SECTION_NAME (dynobj));
8262   if (smsym)
8263     {
8264       Elf32_Internal_Msym msym;
8265
8266       msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
8267       /* It is undocumented what the `1' indicates, but IRIX6 uses
8268          this value.  */
8269       msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
8270       bfd_mips_elf_swap_msym_out
8271         (dynobj, &msym,
8272          ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
8273     }
8274
8275   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
8276   name = h->root.root.string;
8277   if (strcmp (name, "_DYNAMIC") == 0
8278       || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
8279     sym->st_shndx = SHN_ABS;
8280   else if (strcmp (name, "_DYNAMIC_LINK") == 0)
8281     {
8282       sym->st_shndx = SHN_ABS;
8283       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8284       sym->st_value = 1;
8285     }
8286   else if (SGI_COMPAT (output_bfd))
8287     {
8288       if (strcmp (name, "_gp_disp") == 0)
8289         {
8290           sym->st_shndx = SHN_ABS;
8291           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8292           sym->st_value = elf_gp (output_bfd);
8293         }
8294       else if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
8295                || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
8296         {
8297           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8298           sym->st_other = STO_PROTECTED;
8299           sym->st_value = 0;
8300           sym->st_shndx = SHN_MIPS_DATA;
8301         }
8302       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
8303         {
8304           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8305           sym->st_other = STO_PROTECTED;
8306           sym->st_value = mips_elf_hash_table (info)->procedure_count;
8307           sym->st_shndx = SHN_ABS;
8308         }
8309       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
8310         {
8311           if (h->type == STT_FUNC)
8312             sym->st_shndx = SHN_MIPS_TEXT;
8313           else if (h->type == STT_OBJECT)
8314             sym->st_shndx = SHN_MIPS_DATA;
8315         }
8316     }
8317
8318   /* Handle the IRIX6-specific symbols.  */
8319   if (IRIX_COMPAT (output_bfd) == ict_irix6)
8320     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
8321
8322   if (SGI_COMPAT (output_bfd)
8323       && ! info->shared)
8324     {
8325       if (! mips_elf_hash_table (info)->use_rld_obj_head
8326           && strcmp (name, "__rld_map") == 0)
8327         {
8328           asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
8329           BFD_ASSERT (s != NULL);
8330           sym->st_value = s->output_section->vma + s->output_offset;
8331           bfd_put_32 (output_bfd, (bfd_vma) 0, s->contents);
8332           if (mips_elf_hash_table (info)->rld_value == 0)
8333             mips_elf_hash_table (info)->rld_value = sym->st_value;
8334         }
8335       else if (mips_elf_hash_table (info)->use_rld_obj_head
8336                && strcmp (name, "__rld_obj_head") == 0)
8337         {
8338           /* IRIX6 does not use a .rld_map section.  */
8339           if (IRIX_COMPAT (output_bfd) == ict_irix5)
8340             BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
8341                         != NULL);
8342           mips_elf_hash_table (info)->rld_value = sym->st_value;
8343         }
8344     }
8345
8346   /* If this is a mips16 symbol, force the value to be even.  */
8347   if (sym->st_other == STO_MIPS16
8348       && (sym->st_value & 1) != 0)
8349     --sym->st_value;
8350
8351   return true;
8352 }
8353
8354 /* Finish up the dynamic sections.  */
8355
8356 boolean
8357 _bfd_mips_elf_finish_dynamic_sections (output_bfd, info)
8358      bfd *output_bfd;
8359      struct bfd_link_info *info;
8360 {
8361   bfd *dynobj;
8362   asection *sdyn;
8363   asection *sgot;
8364   struct mips_got_info *g;
8365
8366   dynobj = elf_hash_table (info)->dynobj;
8367
8368   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8369
8370   sgot = mips_elf_got_section (dynobj);
8371   if (sgot == NULL)
8372     g = NULL;
8373   else
8374     {
8375       BFD_ASSERT (elf_section_data (sgot) != NULL);
8376       g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8377       BFD_ASSERT (g != NULL);
8378     }
8379
8380   if (elf_hash_table (info)->dynamic_sections_created)
8381     {
8382       bfd_byte *b;
8383
8384       BFD_ASSERT (sdyn != NULL);
8385       BFD_ASSERT (g != NULL);
8386
8387       for (b = sdyn->contents;
8388            b < sdyn->contents + sdyn->_raw_size;
8389            b += MIPS_ELF_DYN_SIZE (dynobj))
8390         {
8391           Elf_Internal_Dyn dyn;
8392           const char *name;
8393           size_t elemsize;
8394           asection *s;
8395           boolean swap_out_p;
8396
8397           /* Read in the current dynamic entry.  */
8398           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
8399
8400           /* Assume that we're going to modify it and write it out.  */
8401           swap_out_p = true;
8402
8403           switch (dyn.d_tag)
8404             {
8405             case DT_RELENT:
8406               s = (bfd_get_section_by_name
8407                    (dynobj,
8408                     MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)));
8409               BFD_ASSERT (s != NULL);
8410               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
8411               break;
8412
8413             case DT_STRSZ:
8414               /* Rewrite DT_STRSZ.  */
8415               dyn.d_un.d_val =
8416                 _bfd_stringtab_size (elf_hash_table (info)->dynstr);
8417               break;
8418
8419             case DT_PLTGOT:
8420               name = ".got";
8421               goto get_vma;
8422             case DT_MIPS_CONFLICT:
8423               name = ".conflict";
8424               goto get_vma;
8425             case DT_MIPS_LIBLIST:
8426               name = ".liblist";
8427             get_vma:
8428               s = bfd_get_section_by_name (output_bfd, name);
8429               BFD_ASSERT (s != NULL);
8430               dyn.d_un.d_ptr = s->vma;
8431               break;
8432
8433             case DT_MIPS_RLD_VERSION:
8434               dyn.d_un.d_val = 1; /* XXX */
8435               break;
8436
8437             case DT_MIPS_FLAGS:
8438               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
8439               break;
8440
8441             case DT_MIPS_CONFLICTNO:
8442               name = ".conflict";
8443               elemsize = sizeof (Elf32_Conflict);
8444               goto set_elemno;
8445
8446             case DT_MIPS_LIBLISTNO:
8447               name = ".liblist";
8448               elemsize = sizeof (Elf32_Lib);
8449             set_elemno:
8450               s = bfd_get_section_by_name (output_bfd, name);
8451               if (s != NULL)
8452                 {
8453                   if (s->_cooked_size != 0)
8454                     dyn.d_un.d_val = s->_cooked_size / elemsize;
8455                   else
8456                     dyn.d_un.d_val = s->_raw_size / elemsize;
8457                 }
8458               else
8459                     dyn.d_un.d_val = 0;
8460               break;
8461
8462             case DT_MIPS_TIME_STAMP:
8463               time ((time_t *) &dyn.d_un.d_val);
8464               break;
8465
8466             case DT_MIPS_ICHECKSUM:
8467               /* XXX FIXME: */
8468               swap_out_p = false;
8469               break;
8470
8471             case DT_MIPS_IVERSION:
8472               /* XXX FIXME: */
8473               swap_out_p = false;
8474               break;
8475
8476             case DT_MIPS_BASE_ADDRESS:
8477               s = output_bfd->sections;
8478               BFD_ASSERT (s != NULL);
8479               dyn.d_un.d_ptr = s->vma & ~(0xffff);
8480               break;
8481
8482             case DT_MIPS_LOCAL_GOTNO:
8483               dyn.d_un.d_val = g->local_gotno;
8484               break;
8485
8486             case DT_MIPS_SYMTABNO:
8487               name = ".dynsym";
8488               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
8489               s = bfd_get_section_by_name (output_bfd, name);
8490               BFD_ASSERT (s != NULL);
8491
8492               if (s->_cooked_size != 0)
8493                 dyn.d_un.d_val = s->_cooked_size / elemsize;
8494               else
8495                 dyn.d_un.d_val = s->_raw_size / elemsize;
8496               break;
8497
8498             case DT_MIPS_UNREFEXTNO:
8499               /* The index into the dynamic symbol table which is the
8500                  entry of the first external symbol that is not
8501                  referenced within the same object.  */
8502               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
8503               break;
8504
8505             case DT_MIPS_GOTSYM:
8506               dyn.d_un.d_val = g->global_gotsym->dynindx;
8507               break;
8508
8509             case DT_MIPS_HIPAGENO:
8510               dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
8511               break;
8512
8513             case DT_MIPS_RLD_MAP:
8514               dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
8515               break;
8516
8517             case DT_MIPS_OPTIONS:
8518               s = (bfd_get_section_by_name
8519                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
8520               dyn.d_un.d_ptr = s->vma;
8521               break;
8522
8523             case DT_MIPS_MSYM:
8524               s = (bfd_get_section_by_name
8525                    (output_bfd, MIPS_ELF_MSYM_SECTION_NAME (output_bfd)));
8526               dyn.d_un.d_ptr = s->vma;
8527               break;
8528
8529             default:
8530               swap_out_p = false;
8531               break;
8532             }
8533
8534           if (swap_out_p)
8535             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
8536               (dynobj, &dyn, b);
8537         }
8538     }
8539
8540   /* The first entry of the global offset table will be filled at
8541      runtime. The second entry will be used by some runtime loaders.
8542      This isn't the case of Irix rld. */
8543   if (sgot != NULL && sgot->_raw_size > 0)
8544     {
8545       MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
8546       MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
8547                          sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
8548     }
8549
8550   if (sgot != NULL)
8551     elf_section_data (sgot->output_section)->this_hdr.sh_entsize
8552       = MIPS_ELF_GOT_SIZE (output_bfd);
8553
8554   {
8555     asection *smsym;
8556     asection *s;
8557     Elf32_compact_rel cpt;
8558
8559     /* ??? The section symbols for the output sections were set up in
8560        _bfd_elf_final_link.  SGI sets the STT_NOTYPE attribute for these
8561        symbols.  Should we do so?  */
8562
8563     smsym = bfd_get_section_by_name (dynobj,
8564                                      MIPS_ELF_MSYM_SECTION_NAME (dynobj));
8565     if (smsym != NULL)
8566       {
8567         Elf32_Internal_Msym msym;
8568
8569         msym.ms_hash_value = 0;
8570         msym.ms_info = ELF32_MS_INFO (0, 1);
8571
8572         for (s = output_bfd->sections; s != NULL; s = s->next)
8573           {
8574             long dynindx = elf_section_data (s)->dynindx;
8575
8576             bfd_mips_elf_swap_msym_out
8577               (output_bfd, &msym,
8578                (((Elf32_External_Msym *) smsym->contents)
8579                 + dynindx));
8580           }
8581       }
8582
8583     if (SGI_COMPAT (output_bfd))
8584       {
8585         /* Write .compact_rel section out.  */
8586         s = bfd_get_section_by_name (dynobj, ".compact_rel");
8587         if (s != NULL)
8588           {
8589             cpt.id1 = 1;
8590             cpt.num = s->reloc_count;
8591             cpt.id2 = 2;
8592             cpt.offset = (s->output_section->filepos
8593                           + sizeof (Elf32_External_compact_rel));
8594             cpt.reserved0 = 0;
8595             cpt.reserved1 = 0;
8596             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
8597                                             ((Elf32_External_compact_rel *)
8598                                              s->contents));
8599
8600             /* Clean up a dummy stub function entry in .text.  */
8601             s = bfd_get_section_by_name (dynobj,
8602                                          MIPS_ELF_STUB_SECTION_NAME (dynobj));
8603             if (s != NULL)
8604               {
8605                 file_ptr dummy_offset;
8606
8607                 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
8608                 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
8609                 memset (s->contents + dummy_offset, 0,
8610                         MIPS_FUNCTION_STUB_SIZE);
8611               }
8612           }
8613       }
8614
8615     /* Clean up a first relocation in .rel.dyn.  */
8616     s = bfd_get_section_by_name (dynobj,
8617                                  MIPS_ELF_REL_DYN_SECTION_NAME (dynobj));
8618     if (s != NULL && s->_raw_size > 0)
8619       memset (s->contents, 0, MIPS_ELF_REL_SIZE (dynobj));
8620   }
8621
8622   return true;
8623 }
8624 \f
8625 /* This is almost identical to bfd_generic_get_... except that some
8626    MIPS relocations need to be handled specially.  Sigh.  */
8627
8628 static bfd_byte *
8629 elf32_mips_get_relocated_section_contents (abfd, link_info, link_order, data,
8630                                            relocateable, symbols)
8631      bfd *abfd;
8632      struct bfd_link_info *link_info;
8633      struct bfd_link_order *link_order;
8634      bfd_byte *data;
8635      boolean relocateable;
8636      asymbol **symbols;
8637 {
8638   /* Get enough memory to hold the stuff */
8639   bfd *input_bfd = link_order->u.indirect.section->owner;
8640   asection *input_section = link_order->u.indirect.section;
8641
8642   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
8643   arelent **reloc_vector = NULL;
8644   long reloc_count;
8645
8646   if (reloc_size < 0)
8647     goto error_return;
8648
8649   reloc_vector = (arelent **) bfd_malloc (reloc_size);
8650   if (reloc_vector == NULL && reloc_size != 0)
8651     goto error_return;
8652
8653   /* read in the section */
8654   if (!bfd_get_section_contents (input_bfd,
8655                                  input_section,
8656                                  (PTR) data,
8657                                  0,
8658                                  input_section->_raw_size))
8659     goto error_return;
8660
8661   /* We're not relaxing the section, so just copy the size info */
8662   input_section->_cooked_size = input_section->_raw_size;
8663   input_section->reloc_done = true;
8664
8665   reloc_count = bfd_canonicalize_reloc (input_bfd,
8666                                         input_section,
8667                                         reloc_vector,
8668                                         symbols);
8669   if (reloc_count < 0)
8670     goto error_return;
8671
8672   if (reloc_count > 0)
8673     {
8674       arelent **parent;
8675       /* for mips */
8676       int gp_found;
8677       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
8678
8679       {
8680         struct bfd_hash_entry *h;
8681         struct bfd_link_hash_entry *lh;
8682         /* Skip all this stuff if we aren't mixing formats.  */
8683         if (abfd && input_bfd
8684             && abfd->xvec == input_bfd->xvec)
8685           lh = 0;
8686         else
8687           {
8688             h = bfd_hash_lookup (&link_info->hash->table, "_gp", false, false);
8689             lh = (struct bfd_link_hash_entry *) h;
8690           }
8691       lookup:
8692         if (lh)
8693           {
8694             switch (lh->type)
8695               {
8696               case bfd_link_hash_undefined:
8697               case bfd_link_hash_undefweak:
8698               case bfd_link_hash_common:
8699                 gp_found = 0;
8700                 break;
8701               case bfd_link_hash_defined:
8702               case bfd_link_hash_defweak:
8703                 gp_found = 1;
8704                 gp = lh->u.def.value;
8705                 break;
8706               case bfd_link_hash_indirect:
8707               case bfd_link_hash_warning:
8708                 lh = lh->u.i.link;
8709                 /* @@FIXME  ignoring warning for now */
8710                 goto lookup;
8711               case bfd_link_hash_new:
8712               default:
8713                 abort ();
8714               }
8715           }
8716         else
8717           gp_found = 0;
8718       }
8719       /* end mips */
8720       for (parent = reloc_vector; *parent != (arelent *) NULL;
8721            parent++)
8722         {
8723           char *error_message = (char *) NULL;
8724           bfd_reloc_status_type r;
8725
8726           /* Specific to MIPS: Deal with relocation types that require
8727              knowing the gp of the output bfd.  */
8728           asymbol *sym = *(*parent)->sym_ptr_ptr;
8729           if (bfd_is_abs_section (sym->section) && abfd)
8730             {
8731               /* The special_function wouldn't get called anyways.  */
8732             }
8733           else if (!gp_found)
8734             {
8735               /* The gp isn't there; let the special function code
8736                  fall over on its own.  */
8737             }
8738           else if ((*parent)->howto->special_function
8739                    == _bfd_mips_elf_gprel16_reloc)
8740             {
8741               /* bypass special_function call */
8742               r = gprel16_with_gp (input_bfd, sym, *parent, input_section,
8743                                    relocateable, (PTR) data, gp);
8744               goto skip_bfd_perform_relocation;
8745             }
8746           /* end mips specific stuff */
8747
8748           r = bfd_perform_relocation (input_bfd,
8749                                       *parent,
8750                                       (PTR) data,
8751                                       input_section,
8752                                       relocateable ? abfd : (bfd *) NULL,
8753                                       &error_message);
8754         skip_bfd_perform_relocation:
8755
8756           if (relocateable)
8757             {
8758               asection *os = input_section->output_section;
8759
8760               /* A partial link, so keep the relocs */
8761               os->orelocation[os->reloc_count] = *parent;
8762               os->reloc_count++;
8763             }
8764
8765           if (r != bfd_reloc_ok)
8766             {
8767               switch (r)
8768                 {
8769                 case bfd_reloc_undefined:
8770                   if (!((*link_info->callbacks->undefined_symbol)
8771                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8772                          input_bfd, input_section, (*parent)->address)))
8773                     goto error_return;
8774                   break;
8775                 case bfd_reloc_dangerous:
8776                   BFD_ASSERT (error_message != (char *) NULL);
8777                   if (!((*link_info->callbacks->reloc_dangerous)
8778                         (link_info, error_message, input_bfd, input_section,
8779                          (*parent)->address)))
8780                     goto error_return;
8781                   break;
8782                 case bfd_reloc_overflow:
8783                   if (!((*link_info->callbacks->reloc_overflow)
8784                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8785                          (*parent)->howto->name, (*parent)->addend,
8786                          input_bfd, input_section, (*parent)->address)))
8787                     goto error_return;
8788                   break;
8789                 case bfd_reloc_outofrange:
8790                 default:
8791                   abort ();
8792                   break;
8793                 }
8794
8795             }
8796         }
8797     }
8798   if (reloc_vector != NULL)
8799     free (reloc_vector);
8800   return data;
8801
8802 error_return:
8803   if (reloc_vector != NULL)
8804     free (reloc_vector);
8805   return NULL;
8806 }
8807 #define bfd_elf32_bfd_get_relocated_section_contents \
8808   elf32_mips_get_relocated_section_contents
8809 \f
8810 /* ECOFF swapping routines.  These are used when dealing with the
8811    .mdebug section, which is in the ECOFF debugging format.  */
8812 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap =
8813 {
8814   /* Symbol table magic number.  */
8815   magicSym,
8816   /* Alignment of debugging information.  E.g., 4.  */
8817   4,
8818   /* Sizes of external symbolic information.  */
8819   sizeof (struct hdr_ext),
8820   sizeof (struct dnr_ext),
8821   sizeof (struct pdr_ext),
8822   sizeof (struct sym_ext),
8823   sizeof (struct opt_ext),
8824   sizeof (struct fdr_ext),
8825   sizeof (struct rfd_ext),
8826   sizeof (struct ext_ext),
8827   /* Functions to swap in external symbolic data.  */
8828   ecoff_swap_hdr_in,
8829   ecoff_swap_dnr_in,
8830   ecoff_swap_pdr_in,
8831   ecoff_swap_sym_in,
8832   ecoff_swap_opt_in,
8833   ecoff_swap_fdr_in,
8834   ecoff_swap_rfd_in,
8835   ecoff_swap_ext_in,
8836   _bfd_ecoff_swap_tir_in,
8837   _bfd_ecoff_swap_rndx_in,
8838   /* Functions to swap out external symbolic data.  */
8839   ecoff_swap_hdr_out,
8840   ecoff_swap_dnr_out,
8841   ecoff_swap_pdr_out,
8842   ecoff_swap_sym_out,
8843   ecoff_swap_opt_out,
8844   ecoff_swap_fdr_out,
8845   ecoff_swap_rfd_out,
8846   ecoff_swap_ext_out,
8847   _bfd_ecoff_swap_tir_out,
8848   _bfd_ecoff_swap_rndx_out,
8849   /* Function to read in symbolic data.  */
8850   _bfd_mips_elf_read_ecoff_info
8851 };
8852 \f
8853 #define TARGET_LITTLE_SYM               bfd_elf32_littlemips_vec
8854 #define TARGET_LITTLE_NAME              "elf32-littlemips"
8855 #define TARGET_BIG_SYM                  bfd_elf32_bigmips_vec
8856 #define TARGET_BIG_NAME                 "elf32-bigmips"
8857 #define ELF_ARCH                        bfd_arch_mips
8858 #define ELF_MACHINE_CODE                EM_MIPS
8859
8860 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
8861    a value of 0x1000, and we are compatible.  */
8862 #define ELF_MAXPAGESIZE                 0x1000
8863
8864 #define elf_backend_collect             true
8865 #define elf_backend_type_change_ok      true
8866 #define elf_backend_can_gc_sections     true
8867 #define elf_info_to_howto               mips_info_to_howto_rela
8868 #define elf_info_to_howto_rel           mips_info_to_howto_rel
8869 #define elf_backend_sym_is_global       mips_elf_sym_is_global
8870 #define elf_backend_object_p            _bfd_mips_elf_object_p
8871 #define elf_backend_section_from_shdr   _bfd_mips_elf_section_from_shdr
8872 #define elf_backend_fake_sections       _bfd_mips_elf_fake_sections
8873 #define elf_backend_section_from_bfd_section \
8874                                         _bfd_mips_elf_section_from_bfd_section
8875 #define elf_backend_section_processing  _bfd_mips_elf_section_processing
8876 #define elf_backend_symbol_processing   _bfd_mips_elf_symbol_processing
8877 #define elf_backend_additional_program_headers \
8878                                         _bfd_mips_elf_additional_program_headers
8879 #define elf_backend_modify_segment_map  _bfd_mips_elf_modify_segment_map
8880 #define elf_backend_final_write_processing \
8881                                         _bfd_mips_elf_final_write_processing
8882 #define elf_backend_ecoff_debug_swap    &mips_elf32_ecoff_debug_swap
8883 #define elf_backend_add_symbol_hook     _bfd_mips_elf_add_symbol_hook
8884 #define elf_backend_create_dynamic_sections \
8885                                         _bfd_mips_elf_create_dynamic_sections
8886 #define elf_backend_check_relocs        _bfd_mips_elf_check_relocs
8887 #define elf_backend_adjust_dynamic_symbol \
8888                                         _bfd_mips_elf_adjust_dynamic_symbol
8889 #define elf_backend_always_size_sections \
8890                                         _bfd_mips_elf_always_size_sections
8891 #define elf_backend_size_dynamic_sections \
8892                                         _bfd_mips_elf_size_dynamic_sections
8893 #define elf_backend_relocate_section    _bfd_mips_elf_relocate_section
8894 #define elf_backend_link_output_symbol_hook \
8895                                         _bfd_mips_elf_link_output_symbol_hook
8896 #define elf_backend_finish_dynamic_symbol \
8897                                         _bfd_mips_elf_finish_dynamic_symbol
8898 #define elf_backend_finish_dynamic_sections \
8899                                         _bfd_mips_elf_finish_dynamic_sections
8900 #define elf_backend_gc_mark_hook        _bfd_mips_elf_gc_mark_hook
8901 #define elf_backend_gc_sweep_hook       _bfd_mips_elf_gc_sweep_hook
8902
8903 #define elf_backend_got_header_size     (4*MIPS_RESERVED_GOTNO)
8904 #define elf_backend_plt_header_size     0
8905
8906 #define bfd_elf32_bfd_is_local_label_name \
8907                                         mips_elf_is_local_label_name
8908 #define bfd_elf32_find_nearest_line     _bfd_mips_elf_find_nearest_line
8909 #define bfd_elf32_set_section_contents  _bfd_mips_elf_set_section_contents
8910 #define bfd_elf32_bfd_link_hash_table_create \
8911                                         _bfd_mips_elf_link_hash_table_create
8912 #define bfd_elf32_bfd_final_link        _bfd_mips_elf_final_link
8913 #define bfd_elf32_bfd_copy_private_bfd_data \
8914                                         _bfd_mips_elf_copy_private_bfd_data
8915 #define bfd_elf32_bfd_merge_private_bfd_data \
8916                                         _bfd_mips_elf_merge_private_bfd_data
8917 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
8918 #define bfd_elf32_bfd_print_private_bfd_data \
8919                                         _bfd_mips_elf_print_private_bfd_data
8920 #include "elf32-target.h"