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