bfd/elfxx-mips.c

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