bfd/elfxx-mips.c

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