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