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