bfd/elfxx-mips.c

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