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