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_boolean mips_elf_overflow_p PARAMS ((bfd_vma, int));
 438 static bfd_vma mips_elf_high PARAMS ((bfd_vma));
 439 static bfd_vma mips_elf_higher PARAMS ((bfd_vma));
 440 static bfd_vma mips_elf_highest PARAMS ((bfd_vma));
 441 static bfd_boolean mips_elf_create_compact_rel_section
 442   PARAMS ((bfd *, struct bfd_link_info *));
 443 static bfd_boolean mips_elf_create_got_section
 444   PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean));
 445 static asection *mips_elf_create_msym_section
 446   PARAMS ((bfd *));
 447 static bfd_reloc_status_type mips_elf_calculate_relocation
 448   PARAMS ((bfd *, bfd *, asection *, struct bfd_link_info *,
 449            const Elf_Internal_Rela *, bfd_vma, reloc_howto_type *,
 450            Elf_Internal_Sym *, asection **, bfd_vma *, const char **,
 451            bfd_boolean *, bfd_boolean));
 452 static bfd_vma mips_elf_obtain_contents
 453   PARAMS ((reloc_howto_type *, const Elf_Internal_Rela *, bfd *, bfd_byte *));
 454 static bfd_boolean mips_elf_perform_relocation
 455   PARAMS ((struct bfd_link_info *, reloc_howto_type *,
 456            const Elf_Internal_Rela *, bfd_vma, bfd *, asection *, bfd_byte *,
 457            bfd_boolean));
 458 static bfd_boolean mips_elf_stub_section_p
 459   PARAMS ((bfd *, asection *));
 460 static void mips_elf_allocate_dynamic_relocations
 461   PARAMS ((bfd *, unsigned int));
 462 static bfd_boolean mips_elf_create_dynamic_relocation
 463   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
 464            struct mips_elf_link_hash_entry *, asection *,
 465            bfd_vma, bfd_vma *, asection *));
 466 static void mips_set_isa_flags PARAMS ((bfd *));
 467 static INLINE char* elf_mips_abi_name PARAMS ((bfd *));
 468 static void mips_elf_irix6_finish_dynamic_symbol
 469   PARAMS ((bfd *, const char *, Elf_Internal_Sym *));
 470 static bfd_boolean mips_mach_extends_p PARAMS ((unsigned long, unsigned long));
 471 static bfd_boolean mips_32bit_flags_p PARAMS ((flagword));
 472 static INLINE hashval_t mips_elf_hash_bfd_vma PARAMS ((bfd_vma));
 473 static hashval_t mips_elf_got_entry_hash PARAMS ((const PTR));
 474 static int mips_elf_got_entry_eq PARAMS ((const PTR, const PTR));
 475
 476 static bfd_boolean mips_elf_multi_got
 477   PARAMS ((bfd *, struct bfd_link_info *, struct mips_got_info *,
 478            asection *, bfd_size_type));
 479 static hashval_t mips_elf_multi_got_entry_hash PARAMS ((const PTR));
 480 static int mips_elf_multi_got_entry_eq PARAMS ((const PTR, const PTR));
 481 static hashval_t mips_elf_bfd2got_entry_hash PARAMS ((const PTR));
 482 static int mips_elf_bfd2got_entry_eq PARAMS ((const PTR, const PTR));
 483 static int mips_elf_make_got_per_bfd PARAMS ((void **, void *));
 484 static int mips_elf_merge_gots PARAMS ((void **, void *));
 485 static int mips_elf_set_global_got_offset PARAMS ((void**, void *));
 486 static int mips_elf_resolve_final_got_entry PARAMS ((void**, void *));
 487 static void mips_elf_resolve_final_got_entries
 488   PARAMS ((struct mips_got_info *));
 489 static bfd_vma mips_elf_adjust_gp
 490   PARAMS ((bfd *, struct mips_got_info *, bfd *));
 491 static struct mips_got_info *mips_elf_got_for_ibfd
 492   PARAMS ((struct mips_got_info *, bfd *));
 493
 494 /* This will be used when we sort the dynamic relocation records.  */
 495 static bfd *reldyn_sorting_bfd;
 496
 497 /* Nonzero if ABFD is using the N32 ABI.  */
 498
 499 #define ABI_N32_P(abfd) \
 500   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
 501
 502 /* Nonzero if ABFD is using the N64 ABI.  */
 503 #define ABI_64_P(abfd) \
 504   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
 505
 506 /* Nonzero if ABFD is using NewABI conventions.  */
 507 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
 508
 509 /* The IRIX compatibility level we are striving for.  */
 510 #define IRIX_COMPAT(abfd) \
 511   (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
 512
 513 /* Whether we are trying to be compatible with IRIX at all.  */
 514 #define SGI_COMPAT(abfd) \
 515   (IRIX_COMPAT (abfd) != ict_none)
 516
 517 /* The name of the options section.  */
 518 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
 519   (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
 520
 521 /* The name of the stub section.  */
 522 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
 523   (NEWABI_P (abfd) ? ".MIPS.stubs" : ".stub")
 524
 525 /* The size of an external REL relocation.  */
 526 #define MIPS_ELF_REL_SIZE(abfd) \
 527   (get_elf_backend_data (abfd)->s->sizeof_rel)
 528
 529 /* The size of an external dynamic table entry.  */
 530 #define MIPS_ELF_DYN_SIZE(abfd) \
 531   (get_elf_backend_data (abfd)->s->sizeof_dyn)
 532
 533 /* The size of a GOT entry.  */
 534 #define MIPS_ELF_GOT_SIZE(abfd) \
 535   (get_elf_backend_data (abfd)->s->arch_size / 8)
 536
 537 /* The size of a symbol-table entry.  */
 538 #define MIPS_ELF_SYM_SIZE(abfd) \
 539   (get_elf_backend_data (abfd)->s->sizeof_sym)
 540
 541 /* The default alignment for sections, as a power of two.  */
 542 #define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \
 543   (get_elf_backend_data (abfd)->s->log_file_align)
 544
 545 /* Get word-sized data.  */
 546 #define MIPS_ELF_GET_WORD(abfd, ptr) \
 547   (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
 548
 549 /* Put out word-sized data.  */
 550 #define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \
 551   (ABI_64_P (abfd)                              \
 552    ? bfd_put_64 (abfd, val, ptr)                \
 553    : bfd_put_32 (abfd, val, ptr))
 554
 555 /* Add a dynamic symbol table-entry.  */
 556 #ifdef BFD64
 557 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)                      \
 558   (ABI_64_P (elf_hash_table (info)->dynobj)                             \
 559    ? bfd_elf64_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val)   \
 560    : bfd_elf32_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
 561 #else
 562 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)                      \
 563   (ABI_64_P (elf_hash_table (info)->dynobj)                             \
 564    ? (abort (), FALSE)                                                  \
 565    : bfd_elf32_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
 566 #endif
 567
 568 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)                      \
 569   (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
 570
 571 /* Determine whether the internal relocation of index REL_IDX is REL
 572    (zero) or RELA (non-zero).  The assumption is that, if there are
 573    two relocation sections for this section, one of them is REL and
 574    the other is RELA.  If the index of the relocation we're testing is
 575    in range for the first relocation section, check that the external
 576    relocation size is that for RELA.  It is also assumed that, if
 577    rel_idx is not in range for the first section, and this first
 578    section contains REL relocs, then the relocation is in the second
 579    section, that is RELA.  */
 580 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx)                           \
 581   ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr)                 \
 582     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel              \
 583     > (bfd_vma)(rel_idx))                                               \
 584    == (elf_section_data (sec)->rel_hdr.sh_entsize                       \
 585        == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela)               \
 586            : sizeof (Elf32_External_Rela))))
 587
 588 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 589    from smaller values.  Start with zero, widen, *then* decrement.  */
 590 #define MINUS_ONE       (((bfd_vma)0) - 1)
 591
 592 /* The number of local .got entries we reserve.  */
 593 #define MIPS_RESERVED_GOTNO (2)
 594
 595 /* The offset of $gp from the beginning of the .got section.  */
 596 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
 597
 598 /* The maximum size of the GOT for it to be addressable using 16-bit
 599    offsets from $gp.  */
 600 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
 601
 602 /* Instructions which appear in a stub.  For some reason the stub is
 603    slightly different on an SGI system.  */
 604 #define STUB_LW(abfd)                                           \
 605   ((ABI_64_P (abfd)                                             \
 606     ? 0xdf998010                /* ld t9,0x8010(gp) */          \
 607     : 0x8f998010))              /* lw t9,0x8010(gp) */
 608 #define STUB_MOVE(abfd)                                         \
 609   (SGI_COMPAT (abfd) ? 0x03e07825 : 0x03e07821)         /* move t7,ra */
 610 #define STUB_JALR 0x0320f809                            /* jal t9 */
 611 #define STUB_LI16(abfd)                                         \
 612   (SGI_COMPAT (abfd) ? 0x34180000 : 0x24180000)         /* ori t8,zero,0 */
 613 #define MIPS_FUNCTION_STUB_SIZE (16)
 614
 615 /* The name of the dynamic interpreter.  This is put in the .interp
 616    section.  */
 617
 618 #define ELF_DYNAMIC_INTERPRETER(abfd)           \
 619    (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
 620     : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
 621     : "/usr/lib/libc.so.1")
 622
 623 #ifdef BFD64
 624 #define MNAME(bfd,pre,pos) \
 625   (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
 626 #define ELF_R_SYM(bfd, i)                                       \
 627   (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
 628 #define ELF_R_TYPE(bfd, i)                                      \
 629   (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
 630 #define ELF_R_INFO(bfd, s, t)                                   \
 631   (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
 632 #else
 633 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
 634 #define ELF_R_SYM(bfd, i)                                       \
 635   (ELF32_R_SYM (i))
 636 #define ELF_R_TYPE(bfd, i)                                      \
 637   (ELF32_R_TYPE (i))
 638 #define ELF_R_INFO(bfd, s, t)                                   \
 639   (ELF32_R_INFO (s, t))
 640 #endif
 641 \f
 642   /* The mips16 compiler uses a couple of special sections to handle
 643      floating point arguments.
 644
 645      Section names that look like .mips16.fn.FNNAME contain stubs that
 646      copy floating point arguments from the fp regs to the gp regs and
 647      then jump to FNNAME.  If any 32 bit function calls FNNAME, the
 648      call should be redirected to the stub instead.  If no 32 bit
 649      function calls FNNAME, the stub should be discarded.  We need to
 650      consider any reference to the function, not just a call, because
 651      if the address of the function is taken we will need the stub,
 652      since the address might be passed to a 32 bit function.
 653
 654      Section names that look like .mips16.call.FNNAME contain stubs
 655      that copy floating point arguments from the gp regs to the fp
 656      regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
 657      then any 16 bit function that calls FNNAME should be redirected
 658      to the stub instead.  If FNNAME is not a 32 bit function, the
 659      stub should be discarded.
 660
 661      .mips16.call.fp.FNNAME sections are similar, but contain stubs
 662      which call FNNAME and then copy the return value from the fp regs
 663      to the gp regs.  These stubs store the return value in $18 while
 664      calling FNNAME; any function which might call one of these stubs
 665      must arrange to save $18 around the call.  (This case is not
 666      needed for 32 bit functions that call 16 bit functions, because
 667      16 bit functions always return floating point values in both
 668      $f0/$f1 and $2/$3.)
 669
 670      Note that in all cases FNNAME might be defined statically.
 671      Therefore, FNNAME is not used literally.  Instead, the relocation
 672      information will indicate which symbol the section is for.
 673
 674      We record any stubs that we find in the symbol table.  */
 675
 676 #define FN_STUB ".mips16.fn."
 677 #define CALL_STUB ".mips16.call."
 678 #define CALL_FP_STUB ".mips16.call.fp."
 679 \f
 680 /* Look up an entry in a MIPS ELF linker hash table.  */
 681
 682 #define mips_elf_link_hash_lookup(table, string, create, copy, follow)  \
 683   ((struct mips_elf_link_hash_entry *)                                  \
 684    elf_link_hash_lookup (&(table)->root, (string), (create),            \
 685                          (copy), (follow)))
 686
 687 /* Traverse a MIPS ELF linker hash table.  */
 688
 689 #define mips_elf_link_hash_traverse(table, func, info)                  \
 690   (elf_link_hash_traverse                                               \
 691    (&(table)->root,                                                     \
 692     (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
 693     (info)))
 694
 695 /* Get the MIPS ELF linker hash table from a link_info structure.  */
 696
 697 #define mips_elf_hash_table(p) \
 698   ((struct mips_elf_link_hash_table *) ((p)->hash))
 699
 700 /* Create an entry in a MIPS ELF linker hash table.  */
 701
 702 static struct bfd_hash_entry *
 703 mips_elf_link_hash_newfunc (entry, table, string)
 704      struct bfd_hash_entry *entry;
 705      struct bfd_hash_table *table;
 706      const char *string;
 707 {
 708   struct mips_elf_link_hash_entry *ret =
 709     (struct mips_elf_link_hash_entry *) entry;
 710
 711   /* Allocate the structure if it has not already been allocated by a
 712      subclass.  */
 713   if (ret == (struct mips_elf_link_hash_entry *) NULL)
 714     ret = ((struct mips_elf_link_hash_entry *)
 715            bfd_hash_allocate (table,
 716                               sizeof (struct mips_elf_link_hash_entry)));
 717   if (ret == (struct mips_elf_link_hash_entry *) NULL)
 718     return (struct bfd_hash_entry *) ret;
 719
 720   /* Call the allocation method of the superclass.  */
 721   ret = ((struct mips_elf_link_hash_entry *)
 722          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 723                                      table, string));
 724   if (ret != (struct mips_elf_link_hash_entry *) NULL)
 725     {
 726       /* Set local fields.  */
 727       memset (&ret->esym, 0, sizeof (EXTR));
 728       /* We use -2 as a marker to indicate that the information has
 729          not been set.  -1 means there is no associated ifd.  */
 730       ret->esym.ifd = -2;
 731       ret->possibly_dynamic_relocs = 0;
 732       ret->readonly_reloc = FALSE;
 733       ret->min_dyn_reloc_index = 0;
 734       ret->no_fn_stub = FALSE;
 735       ret->fn_stub = NULL;
 736       ret->need_fn_stub = FALSE;
 737       ret->call_stub = NULL;
 738       ret->call_fp_stub = NULL;
 739       ret->forced_local = FALSE;
 740     }
 741
 742   return (struct bfd_hash_entry *) ret;
 743 }
 744
 745 bfd_boolean
 746 _bfd_mips_elf_new_section_hook (abfd, sec)
 747      bfd *abfd;
 748      asection *sec;
 749 {
 750   struct _mips_elf_section_data *sdata;
 751   bfd_size_type amt = sizeof (*sdata);
 752
 753   sdata = (struct _mips_elf_section_data *) bfd_zalloc (abfd, amt);
 754   if (sdata == NULL)
 755     return FALSE;
 756   sec->used_by_bfd = (PTR) sdata;
 757
 758   return _bfd_elf_new_section_hook (abfd, sec);
 759 }
 760 \f
 761 /* Read ECOFF debugging information from a .mdebug section into a
 762    ecoff_debug_info structure.  */
 763
 764 bfd_boolean
 765 _bfd_mips_elf_read_ecoff_info (abfd, section, debug)
 766      bfd *abfd;
 767      asection *section;
 768      struct ecoff_debug_info *debug;
 769 {
 770   HDRR *symhdr;
 771   const struct ecoff_debug_swap *swap;
 772   char *ext_hdr = NULL;
 773
 774   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 775   memset (debug, 0, sizeof (*debug));
 776
 777   ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
 778   if (ext_hdr == NULL && swap->external_hdr_size != 0)
 779     goto error_return;
 780
 781   if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
 782                                   swap->external_hdr_size))
 783     goto error_return;
 784
 785   symhdr = &debug->symbolic_header;
 786   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
 787
 788   /* The symbolic header contains absolute file offsets and sizes to
 789      read.  */
 790 #define READ(ptr, offset, count, size, type)                            \
 791   if (symhdr->count == 0)                                               \
 792     debug->ptr = NULL;                                                  \
 793   else                                                                  \
 794     {                                                                   \
 795       bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
 796       debug->ptr = (type) bfd_malloc (amt);                             \
 797       if (debug->ptr == NULL)                                           \
 798         goto error_return;                                              \
 799       if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0     \
 800           || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
 801         goto error_return;                                              \
 802     }
 803
 804   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
 805   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
 806   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
 807   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
 808   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
 809   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
 810         union aux_ext *);
 811   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
 812   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
 813   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
 814   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
 815   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
 816 #undef READ
 817
 818   debug->fdr = NULL;
 819   debug->adjust = NULL;
 820
 821   return TRUE;
 822
 823  error_return:
 824   if (ext_hdr != NULL)
 825     free (ext_hdr);
 826   if (debug->line != NULL)
 827     free (debug->line);
 828   if (debug->external_dnr != NULL)
 829     free (debug->external_dnr);
 830   if (debug->external_pdr != NULL)
 831     free (debug->external_pdr);
 832   if (debug->external_sym != NULL)
 833     free (debug->external_sym);
 834   if (debug->external_opt != NULL)
 835     free (debug->external_opt);
 836   if (debug->external_aux != NULL)
 837     free (debug->external_aux);
 838   if (debug->ss != NULL)
 839     free (debug->ss);
 840   if (debug->ssext != NULL)
 841     free (debug->ssext);
 842   if (debug->external_fdr != NULL)
 843     free (debug->external_fdr);
 844   if (debug->external_rfd != NULL)
 845     free (debug->external_rfd);
 846   if (debug->external_ext != NULL)
 847     free (debug->external_ext);
 848   return FALSE;
 849 }
 850 \f
 851 /* Swap RPDR (runtime procedure table entry) for output.  */
 852
 853 static void
 854 ecoff_swap_rpdr_out (abfd, in, ex)
 855      bfd *abfd;
 856      const RPDR *in;
 857      struct rpdr_ext *ex;
 858 {
 859   H_PUT_S32 (abfd, in->adr, ex->p_adr);
 860   H_PUT_32 (abfd, in->regmask, ex->p_regmask);
 861   H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
 862   H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
 863   H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
 864   H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
 865
 866   H_PUT_16 (abfd, in->framereg, ex->p_framereg);
 867   H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
 868
 869   H_PUT_32 (abfd, in->irpss, ex->p_irpss);
 870 #if 0 /* FIXME */
 871   H_PUT_S32 (abfd, in->exception_info, ex->p_exception_info);
 872 #endif
 873 }
 874
 875 /* Create a runtime procedure table from the .mdebug section.  */
 876
 877 static bfd_boolean
 878 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
 879      PTR handle;
 880      bfd *abfd;
 881      struct bfd_link_info *info;
 882      asection *s;
 883      struct ecoff_debug_info *debug;
 884 {
 885   const struct ecoff_debug_swap *swap;
 886   HDRR *hdr = &debug->symbolic_header;
 887   RPDR *rpdr, *rp;
 888   struct rpdr_ext *erp;
 889   PTR rtproc;
 890   struct pdr_ext *epdr;
 891   struct sym_ext *esym;
 892   char *ss, **sv;
 893   char *str;
 894   bfd_size_type size;
 895   bfd_size_type count;
 896   unsigned long sindex;
 897   unsigned long i;
 898   PDR pdr;
 899   SYMR sym;
 900   const char *no_name_func = _("static procedure (no name)");
 901
 902   epdr = NULL;
 903   rpdr = NULL;
 904   esym = NULL;
 905   ss = NULL;
 906   sv = NULL;
 907
 908   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 909
 910   sindex = strlen (no_name_func) + 1;
 911   count = hdr->ipdMax;
 912   if (count > 0)
 913     {
 914       size = swap->external_pdr_size;
 915
 916       epdr = (struct pdr_ext *) bfd_malloc (size * count);
 917       if (epdr == NULL)
 918         goto error_return;
 919
 920       if (! _bfd_ecoff_get_accumulated_pdr (handle, (PTR) epdr))
 921         goto error_return;
 922
 923       size = sizeof (RPDR);
 924       rp = rpdr = (RPDR *) bfd_malloc (size * count);
 925       if (rpdr == NULL)
 926         goto error_return;
 927
 928       size = sizeof (char *);
 929       sv = (char **) bfd_malloc (size * count);
 930       if (sv == NULL)
 931         goto error_return;
 932
 933       count = hdr->isymMax;
 934       size = swap->external_sym_size;
 935       esym = (struct sym_ext *) bfd_malloc (size * count);
 936       if (esym == NULL)
 937         goto error_return;
 938
 939       if (! _bfd_ecoff_get_accumulated_sym (handle, (PTR) esym))
 940         goto error_return;
 941
 942       count = hdr->issMax;
 943       ss = (char *) bfd_malloc (count);
 944       if (ss == NULL)
 945         goto error_return;
 946       if (! _bfd_ecoff_get_accumulated_ss (handle, (PTR) ss))
 947         goto error_return;
 948
 949       count = hdr->ipdMax;
 950       for (i = 0; i < (unsigned long) count; i++, rp++)
 951         {
 952           (*swap->swap_pdr_in) (abfd, (PTR) (epdr + i), &pdr);
 953           (*swap->swap_sym_in) (abfd, (PTR) &esym[pdr.isym], &sym);
 954           rp->adr = sym.value;
 955           rp->regmask = pdr.regmask;
 956           rp->regoffset = pdr.regoffset;
 957           rp->fregmask = pdr.fregmask;
 958           rp->fregoffset = pdr.fregoffset;
 959           rp->frameoffset = pdr.frameoffset;
 960           rp->framereg = pdr.framereg;
 961           rp->pcreg = pdr.pcreg;
 962           rp->irpss = sindex;
 963           sv[i] = ss + sym.iss;
 964           sindex += strlen (sv[i]) + 1;
 965         }
 966     }
 967
 968   size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
 969   size = BFD_ALIGN (size, 16);
 970   rtproc = (PTR) bfd_alloc (abfd, size);
 971   if (rtproc == NULL)
 972     {
 973       mips_elf_hash_table (info)->procedure_count = 0;
 974       goto error_return;
 975     }
 976
 977   mips_elf_hash_table (info)->procedure_count = count + 2;
 978
 979   erp = (struct rpdr_ext *) rtproc;
 980   memset (erp, 0, sizeof (struct rpdr_ext));
 981   erp++;
 982   str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
 983   strcpy (str, no_name_func);
 984   str += strlen (no_name_func) + 1;
 985   for (i = 0; i < count; i++)
 986     {
 987       ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
 988       strcpy (str, sv[i]);
 989       str += strlen (sv[i]) + 1;
 990     }
 991   H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
 992
 993   /* Set the size and contents of .rtproc section.  */
 994   s->_raw_size = size;
 995   s->contents = (bfd_byte *) rtproc;
 996
 997   /* Skip this section later on (I don't think this currently
 998      matters, but someday it might).  */
 999   s->link_order_head = (struct bfd_link_order *) NULL;
1000
1001   if (epdr != NULL)
1002     free (epdr);
1003   if (rpdr != NULL)
1004     free (rpdr);
1005   if (esym != NULL)
1006     free (esym);
1007   if (ss != NULL)
1008     free (ss);
1009   if (sv != NULL)
1010     free (sv);
1011
1012   return TRUE;
1013
1014  error_return:
1015   if (epdr != NULL)
1016     free (epdr);
1017   if (rpdr != NULL)
1018     free (rpdr);
1019   if (esym != NULL)
1020     free (esym);
1021   if (ss != NULL)
1022     free (ss);
1023   if (sv != NULL)
1024     free (sv);
1025   return FALSE;
1026 }
1027
1028 /* Check the mips16 stubs for a particular symbol, and see if we can
1029    discard them.  */
1030
1031 static bfd_boolean
1032 mips_elf_check_mips16_stubs (h, data)
1033      struct mips_elf_link_hash_entry *h;
1034      PTR data ATTRIBUTE_UNUSED;
1035 {
1036   if (h->root.root.type == bfd_link_hash_warning)
1037     h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1038
1039   if (h->fn_stub != NULL
1040       && ! h->need_fn_stub)
1041     {
1042       /* We don't need the fn_stub; the only references to this symbol
1043          are 16 bit calls.  Clobber the size to 0 to prevent it from
1044          being included in the link.  */
1045       h->fn_stub->_raw_size = 0;
1046       h->fn_stub->_cooked_size = 0;
1047       h->fn_stub->flags &= ~SEC_RELOC;
1048       h->fn_stub->reloc_count = 0;
1049       h->fn_stub->flags |= SEC_EXCLUDE;
1050     }
1051
1052   if (h->call_stub != NULL
1053       && h->root.other == STO_MIPS16)
1054     {
1055       /* We don't need the call_stub; this is a 16 bit function, so
1056          calls from other 16 bit functions are OK.  Clobber the size
1057          to 0 to prevent it from being included in the link.  */
1058       h->call_stub->_raw_size = 0;
1059       h->call_stub->_cooked_size = 0;
1060       h->call_stub->flags &= ~SEC_RELOC;
1061       h->call_stub->reloc_count = 0;
1062       h->call_stub->flags |= SEC_EXCLUDE;
1063     }
1064
1065   if (h->call_fp_stub != NULL
1066       && h->root.other == STO_MIPS16)
1067     {
1068       /* We don't need the call_stub; this is a 16 bit function, so
1069          calls from other 16 bit functions are OK.  Clobber the size
1070          to 0 to prevent it from being included in the link.  */
1071       h->call_fp_stub->_raw_size = 0;
1072       h->call_fp_stub->_cooked_size = 0;
1073       h->call_fp_stub->flags &= ~SEC_RELOC;
1074       h->call_fp_stub->reloc_count = 0;
1075       h->call_fp_stub->flags |= SEC_EXCLUDE;
1076     }
1077
1078   return TRUE;
1079 }
1080 \f
1081 bfd_reloc_status_type
1082 _bfd_mips_elf_gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1083                                relocatable, data, gp)
1084      bfd *abfd;
1085      asymbol *symbol;
1086      arelent *reloc_entry;
1087      asection *input_section;
1088      bfd_boolean relocatable;
1089      PTR data;
1090      bfd_vma gp;
1091 {
1092   bfd_vma relocation;
1093   unsigned long insn = 0;
1094   bfd_signed_vma val;
1095
1096   if (bfd_is_com_section (symbol->section))
1097     relocation = 0;
1098   else
1099     relocation = symbol->value;
1100
1101   relocation += symbol->section->output_section->vma;
1102   relocation += symbol->section->output_offset;
1103
1104   if (reloc_entry->address > input_section->_cooked_size)
1105     return bfd_reloc_outofrange;
1106
1107   /* Set val to the offset into the section or symbol.  */
1108   val = reloc_entry->addend;
1109
1110   if (reloc_entry->howto->partial_inplace)
1111     {
1112       insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1113       val += insn & 0xffff;
1114     }
1115
1116   _bfd_mips_elf_sign_extend(val, 16);
1117
1118   /* Adjust val for the final section location and GP value.  If we
1119      are producing relocatable output, we don't want to do this for
1120      an external symbol.  */
1121   if (! relocatable
1122       || (symbol->flags & BSF_SECTION_SYM) != 0)
1123     val += relocation - gp;
1124
1125   if (reloc_entry->howto->partial_inplace)
1126     {
1127       insn = (insn & ~0xffff) | (val & 0xffff);
1128       bfd_put_32 (abfd, (bfd_vma) insn,
1129                   (bfd_byte *) data + reloc_entry->address);
1130     }
1131   else
1132     reloc_entry->addend = val;
1133
1134   if (relocatable)
1135     reloc_entry->address += input_section->output_offset;
1136   else if (((val & ~0xffff) != ~0xffff) && ((val & ~0xffff) != 0))
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                                           MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
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 bfd_vma
2745 _bfd_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, MIPS_ELF_LOG_FILE_ALIGN (abfd)))
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->relocatable
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->relocatable
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->relocatable
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 + _bfd_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 + _bfd_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 = (_bfd_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 = _bfd_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 = _bfd_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 relocatable 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 relocatable 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->relocatable)
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 (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 default
4643    kind of relocations.  We used to set up a second header for the
4644    non-default kind of relocations here, but only NewABI would use
4645    these, and the IRIX ld doesn't like resulting empty RELA sections.
4646    Thus we create those header only on demand now.  */
4647
4648   return TRUE;
4649 }
4650
4651 /* Given a BFD section, try to locate the corresponding ELF section
4652    index.  This is used by both the 32-bit and the 64-bit ABI.
4653    Actually, it's not clear to me that the 64-bit ABI supports these,
4654    but for non-PIC objects we will certainly want support for at least
4655    the .scommon section.  */
4656
4657 bfd_boolean
4658 _bfd_mips_elf_section_from_bfd_section (abfd, sec, retval)
4659      bfd *abfd ATTRIBUTE_UNUSED;
4660      asection *sec;
4661      int *retval;
4662 {
4663   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
4664     {
4665       *retval = SHN_MIPS_SCOMMON;
4666       return TRUE;
4667     }
4668   if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
4669     {
4670       *retval = SHN_MIPS_ACOMMON;
4671       return TRUE;
4672     }
4673   return FALSE;
4674 }
4675 \f
4676 /* Hook called by the linker routine which adds symbols from an object
4677    file.  We must handle the special MIPS section numbers here.  */
4678
4679 bfd_boolean
4680 _bfd_mips_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4681      bfd *abfd;
4682      struct bfd_link_info *info;
4683      const Elf_Internal_Sym *sym;
4684      const char **namep;
4685      flagword *flagsp ATTRIBUTE_UNUSED;
4686      asection **secp;
4687      bfd_vma *valp;
4688 {
4689   if (SGI_COMPAT (abfd)
4690       && (abfd->flags & DYNAMIC) != 0
4691       && strcmp (*namep, "_rld_new_interface") == 0)
4692     {
4693       /* Skip IRIX5 rld entry name.  */
4694       *namep = NULL;
4695       return TRUE;
4696     }
4697
4698   switch (sym->st_shndx)
4699     {
4700     case SHN_COMMON:
4701       /* Common symbols less than the GP size are automatically
4702          treated as SHN_MIPS_SCOMMON symbols.  */
4703       if (sym->st_size > elf_gp_size (abfd)
4704           || IRIX_COMPAT (abfd) == ict_irix6)
4705         break;
4706       /* Fall through.  */
4707     case SHN_MIPS_SCOMMON:
4708       *secp = bfd_make_section_old_way (abfd, ".scommon");
4709       (*secp)->flags |= SEC_IS_COMMON;
4710       *valp = sym->st_size;
4711       break;
4712
4713     case SHN_MIPS_TEXT:
4714       /* This section is used in a shared object.  */
4715       if (elf_tdata (abfd)->elf_text_section == NULL)
4716         {
4717           asymbol *elf_text_symbol;
4718           asection *elf_text_section;
4719           bfd_size_type amt = sizeof (asection);
4720
4721           elf_text_section = bfd_zalloc (abfd, amt);
4722           if (elf_text_section == NULL)
4723             return FALSE;
4724
4725           amt = sizeof (asymbol);
4726           elf_text_symbol = bfd_zalloc (abfd, amt);
4727           if (elf_text_symbol == NULL)
4728             return FALSE;
4729
4730           /* Initialize the section.  */
4731
4732           elf_tdata (abfd)->elf_text_section = elf_text_section;
4733           elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
4734
4735           elf_text_section->symbol = elf_text_symbol;
4736           elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
4737
4738           elf_text_section->name = ".text";
4739           elf_text_section->flags = SEC_NO_FLAGS;
4740           elf_text_section->output_section = NULL;
4741           elf_text_section->owner = abfd;
4742           elf_text_symbol->name = ".text";
4743           elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4744           elf_text_symbol->section = elf_text_section;
4745         }
4746       /* This code used to do *secp = bfd_und_section_ptr if
4747          info->shared.  I don't know why, and that doesn't make sense,
4748          so I took it out.  */
4749       *secp = elf_tdata (abfd)->elf_text_section;
4750       break;
4751
4752     case SHN_MIPS_ACOMMON:
4753       /* Fall through. XXX Can we treat this as allocated data?  */
4754     case SHN_MIPS_DATA:
4755       /* This section is used in a shared object.  */
4756       if (elf_tdata (abfd)->elf_data_section == NULL)
4757         {
4758           asymbol *elf_data_symbol;
4759           asection *elf_data_section;
4760           bfd_size_type amt = sizeof (asection);
4761
4762           elf_data_section = bfd_zalloc (abfd, amt);
4763           if (elf_data_section == NULL)
4764             return FALSE;
4765
4766           amt = sizeof (asymbol);
4767           elf_data_symbol = bfd_zalloc (abfd, amt);
4768           if (elf_data_symbol == NULL)
4769             return FALSE;
4770
4771           /* Initialize the section.  */
4772
4773           elf_tdata (abfd)->elf_data_section = elf_data_section;
4774           elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
4775
4776           elf_data_section->symbol = elf_data_symbol;
4777           elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
4778
4779           elf_data_section->name = ".data";
4780           elf_data_section->flags = SEC_NO_FLAGS;
4781           elf_data_section->output_section = NULL;
4782           elf_data_section->owner = abfd;
4783           elf_data_symbol->name = ".data";
4784           elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4785           elf_data_symbol->section = elf_data_section;
4786         }
4787       /* This code used to do *secp = bfd_und_section_ptr if
4788          info->shared.  I don't know why, and that doesn't make sense,
4789          so I took it out.  */
4790       *secp = elf_tdata (abfd)->elf_data_section;
4791       break;
4792
4793     case SHN_MIPS_SUNDEFINED:
4794       *secp = bfd_und_section_ptr;
4795       break;
4796     }
4797
4798   if (SGI_COMPAT (abfd)
4799       && ! info->shared
4800       && info->hash->creator == abfd->xvec
4801       && strcmp (*namep, "__rld_obj_head") == 0)
4802     {
4803       struct elf_link_hash_entry *h;
4804       struct bfd_link_hash_entry *bh;
4805
4806       /* Mark __rld_obj_head as dynamic.  */
4807       bh = NULL;
4808       if (! (_bfd_generic_link_add_one_symbol
4809              (info, abfd, *namep, BSF_GLOBAL, *secp,
4810               (bfd_vma) *valp, (const char *) NULL, FALSE,
4811               get_elf_backend_data (abfd)->collect, &bh)))
4812         return FALSE;
4813
4814       h = (struct elf_link_hash_entry *) bh;
4815       h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4816       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4817       h->type = STT_OBJECT;
4818
4819       if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4820         return FALSE;
4821
4822       mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
4823     }
4824
4825   /* If this is a mips16 text symbol, add 1 to the value to make it
4826      odd.  This will cause something like .word SYM to come up with
4827      the right value when it is loaded into the PC.  */
4828   if (sym->st_other == STO_MIPS16)
4829     ++*valp;
4830
4831   return TRUE;
4832 }
4833
4834 /* This hook function is called before the linker writes out a global
4835    symbol.  We mark symbols as small common if appropriate.  This is
4836    also where we undo the increment of the value for a mips16 symbol.  */
4837
4838 bfd_boolean
4839 _bfd_mips_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
4840      bfd *abfd ATTRIBUTE_UNUSED;
4841      struct bfd_link_info *info ATTRIBUTE_UNUSED;
4842      const char *name ATTRIBUTE_UNUSED;
4843      Elf_Internal_Sym *sym;
4844      asection *input_sec;
4845 {
4846   /* If we see a common symbol, which implies a relocatable link, then
4847      if a symbol was small common in an input file, mark it as small
4848      common in the output file.  */
4849   if (sym->st_shndx == SHN_COMMON
4850       && strcmp (input_sec->name, ".scommon") == 0)
4851     sym->st_shndx = SHN_MIPS_SCOMMON;
4852
4853   if (sym->st_other == STO_MIPS16
4854       && (sym->st_value & 1) != 0)
4855     --sym->st_value;
4856
4857   return TRUE;
4858 }
4859 \f
4860 /* Functions for the dynamic linker.  */
4861
4862 /* Create dynamic sections when linking against a dynamic object.  */
4863
4864 bfd_boolean
4865 _bfd_mips_elf_create_dynamic_sections (abfd, info)
4866      bfd *abfd;
4867      struct bfd_link_info *info;
4868 {
4869   struct elf_link_hash_entry *h;
4870   struct bfd_link_hash_entry *bh;
4871   flagword flags;
4872   register asection *s;
4873   const char * const *namep;
4874
4875   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4876            | SEC_LINKER_CREATED | SEC_READONLY);
4877
4878   /* Mips ABI requests the .dynamic section to be read only.  */
4879   s = bfd_get_section_by_name (abfd, ".dynamic");
4880   if (s != NULL)
4881     {
4882       if (! bfd_set_section_flags (abfd, s, flags))
4883         return FALSE;
4884     }
4885
4886   /* We need to create .got section.  */
4887   if (! mips_elf_create_got_section (abfd, info, FALSE))
4888     return FALSE;
4889
4890   if (! mips_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
4891     return FALSE;
4892
4893   /* Create the .msym section on IRIX6.  It is used by the dynamic
4894      linker to speed up dynamic relocations, and to avoid computing
4895      the ELF hash for symbols.  */
4896   if (IRIX_COMPAT (abfd) == ict_irix6
4897       && !mips_elf_create_msym_section (abfd))
4898     return FALSE;
4899
4900   /* Create .stub section.  */
4901   if (bfd_get_section_by_name (abfd,
4902                                MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
4903     {
4904       s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
4905       if (s == NULL
4906           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4907           || ! bfd_set_section_alignment (abfd, s,
4908                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4909         return FALSE;
4910     }
4911
4912   if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
4913       && !info->shared
4914       && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
4915     {
4916       s = bfd_make_section (abfd, ".rld_map");
4917       if (s == NULL
4918           || ! bfd_set_section_flags (abfd, s, flags &~ (flagword) SEC_READONLY)
4919           || ! bfd_set_section_alignment (abfd, s,
4920                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4921         return FALSE;
4922     }
4923
4924   /* On IRIX5, we adjust add some additional symbols and change the
4925      alignments of several sections.  There is no ABI documentation
4926      indicating that this is necessary on IRIX6, nor any evidence that
4927      the linker takes such action.  */
4928   if (IRIX_COMPAT (abfd) == ict_irix5)
4929     {
4930       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
4931         {
4932           bh = NULL;
4933           if (! (_bfd_generic_link_add_one_symbol
4934                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr,
4935                   (bfd_vma) 0, (const char *) NULL, FALSE,
4936                   get_elf_backend_data (abfd)->collect, &bh)))
4937             return FALSE;
4938
4939           h = (struct elf_link_hash_entry *) bh;
4940           h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4941           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4942           h->type = STT_SECTION;
4943
4944           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4945             return FALSE;
4946         }
4947
4948       /* We need to create a .compact_rel section.  */
4949       if (SGI_COMPAT (abfd))
4950         {
4951           if (!mips_elf_create_compact_rel_section (abfd, info))
4952             return FALSE;
4953         }
4954
4955       /* Change alignments of some sections.  */
4956       s = bfd_get_section_by_name (abfd, ".hash");
4957       if (s != NULL)
4958         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4959       s = bfd_get_section_by_name (abfd, ".dynsym");
4960       if (s != NULL)
4961         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4962       s = bfd_get_section_by_name (abfd, ".dynstr");
4963       if (s != NULL)
4964         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4965       s = bfd_get_section_by_name (abfd, ".reginfo");
4966       if (s != NULL)
4967         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4968       s = bfd_get_section_by_name (abfd, ".dynamic");
4969       if (s != NULL)
4970         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4971     }
4972
4973   if (!info->shared)
4974     {
4975       const char *name;
4976
4977       name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4978       bh = NULL;
4979       if (!(_bfd_generic_link_add_one_symbol
4980             (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr,
4981              (bfd_vma) 0, (const char *) NULL, FALSE,
4982              get_elf_backend_data (abfd)->collect, &bh)))
4983         return FALSE;
4984
4985       h = (struct elf_link_hash_entry *) bh;
4986       h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4987       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4988       h->type = STT_SECTION;
4989
4990       if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4991         return FALSE;
4992
4993       if (! mips_elf_hash_table (info)->use_rld_obj_head)
4994         {
4995           /* __rld_map is a four byte word located in the .data section
4996              and is filled in by the rtld to contain a pointer to
4997              the _r_debug structure. Its symbol value will be set in
4998              _bfd_mips_elf_finish_dynamic_symbol.  */
4999           s = bfd_get_section_by_name (abfd, ".rld_map");
5000           BFD_ASSERT (s != NULL);
5001
5002           name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
5003           bh = NULL;
5004           if (!(_bfd_generic_link_add_one_symbol
5005                 (info, abfd, name, BSF_GLOBAL, s,
5006                  (bfd_vma) 0, (const char *) NULL, FALSE,
5007                  get_elf_backend_data (abfd)->collect, &bh)))
5008             return FALSE;
5009
5010           h = (struct elf_link_hash_entry *) bh;
5011           h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5012           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5013           h->type = STT_OBJECT;
5014
5015           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
5016             return FALSE;
5017         }
5018     }
5019
5020   return TRUE;
5021 }
5022 \f
5023 /* Look through the relocs for a section during the first phase, and
5024    allocate space in the global offset table.  */
5025
5026 bfd_boolean
5027 _bfd_mips_elf_check_relocs (abfd, info, sec, relocs)
5028      bfd *abfd;
5029      struct bfd_link_info *info;
5030      asection *sec;
5031      const Elf_Internal_Rela *relocs;
5032 {
5033   const char *name;
5034   bfd *dynobj;
5035   Elf_Internal_Shdr *symtab_hdr;
5036   struct elf_link_hash_entry **sym_hashes;
5037   struct mips_got_info *g;
5038   size_t extsymoff;
5039   const Elf_Internal_Rela *rel;
5040   const Elf_Internal_Rela *rel_end;
5041   asection *sgot;
5042   asection *sreloc;
5043   struct elf_backend_data *bed;
5044
5045   if (info->relocatable)
5046     return TRUE;
5047
5048   dynobj = elf_hash_table (info)->dynobj;
5049   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5050   sym_hashes = elf_sym_hashes (abfd);
5051   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5052
5053   /* Check for the mips16 stub sections.  */
5054
5055   name = bfd_get_section_name (abfd, sec);
5056   if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5057     {
5058       unsigned long r_symndx;
5059
5060       /* Look at the relocation information to figure out which symbol
5061          this is for.  */
5062
5063       r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5064
5065       if (r_symndx < extsymoff
5066           || sym_hashes[r_symndx - extsymoff] == NULL)
5067         {
5068           asection *o;
5069
5070           /* This stub is for a local symbol.  This stub will only be
5071              needed if there is some relocation in this BFD, other
5072              than a 16 bit function call, which refers to this symbol.  */
5073           for (o = abfd->sections; o != NULL; o = o->next)
5074             {
5075               Elf_Internal_Rela *sec_relocs;
5076               const Elf_Internal_Rela *r, *rend;
5077
5078               /* We can ignore stub sections when looking for relocs.  */
5079               if ((o->flags & SEC_RELOC) == 0
5080                   || o->reloc_count == 0
5081                   || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5082                               sizeof FN_STUB - 1) == 0
5083                   || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5084                               sizeof CALL_STUB - 1) == 0
5085                   || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5086                               sizeof CALL_FP_STUB - 1) == 0)
5087                 continue;
5088
5089               sec_relocs
5090                 = _bfd_elf_link_read_relocs (abfd, o, (PTR) NULL,
5091                                              (Elf_Internal_Rela *) NULL,
5092                                              info->keep_memory);
5093               if (sec_relocs == NULL)
5094                 return FALSE;
5095
5096               rend = sec_relocs + o->reloc_count;
5097               for (r = sec_relocs; r < rend; r++)
5098                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
5099                     && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
5100                   break;
5101
5102               if (elf_section_data (o)->relocs != sec_relocs)
5103                 free (sec_relocs);
5104
5105               if (r < rend)
5106                 break;
5107             }
5108
5109           if (o == NULL)
5110             {
5111               /* There is no non-call reloc for this stub, so we do
5112                  not need it.  Since this function is called before
5113                  the linker maps input sections to output sections, we
5114                  can easily discard it by setting the SEC_EXCLUDE
5115                  flag.  */
5116               sec->flags |= SEC_EXCLUDE;
5117               return TRUE;
5118             }
5119
5120           /* Record this stub in an array of local symbol stubs for
5121              this BFD.  */
5122           if (elf_tdata (abfd)->local_stubs == NULL)
5123             {
5124               unsigned long symcount;
5125               asection **n;
5126               bfd_size_type amt;
5127
5128               if (elf_bad_symtab (abfd))
5129                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5130               else
5131                 symcount = symtab_hdr->sh_info;
5132               amt = symcount * sizeof (asection *);
5133               n = (asection **) bfd_zalloc (abfd, amt);
5134               if (n == NULL)
5135                 return FALSE;
5136               elf_tdata (abfd)->local_stubs = n;
5137             }
5138
5139           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5140
5141           /* We don't need to set mips16_stubs_seen in this case.
5142              That flag is used to see whether we need to look through
5143              the global symbol table for stubs.  We don't need to set
5144              it here, because we just have a local stub.  */
5145         }
5146       else
5147         {
5148           struct mips_elf_link_hash_entry *h;
5149
5150           h = ((struct mips_elf_link_hash_entry *)
5151                sym_hashes[r_symndx - extsymoff]);
5152
5153           /* H is the symbol this stub is for.  */
5154
5155           h->fn_stub = sec;
5156           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5157         }
5158     }
5159   else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5160            || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5161     {
5162       unsigned long r_symndx;
5163       struct mips_elf_link_hash_entry *h;
5164       asection **loc;
5165
5166       /* Look at the relocation information to figure out which symbol
5167          this is for.  */
5168
5169       r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5170
5171       if (r_symndx < extsymoff
5172           || sym_hashes[r_symndx - extsymoff] == NULL)
5173         {
5174           /* This stub was actually built for a static symbol defined
5175              in the same file.  We assume that all static symbols in
5176              mips16 code are themselves mips16, so we can simply
5177              discard this stub.  Since this function is called before
5178              the linker maps input sections to output sections, we can
5179              easily discard it by setting the SEC_EXCLUDE flag.  */
5180           sec->flags |= SEC_EXCLUDE;
5181           return TRUE;
5182         }
5183
5184       h = ((struct mips_elf_link_hash_entry *)
5185            sym_hashes[r_symndx - extsymoff]);
5186
5187       /* H is the symbol this stub is for.  */
5188
5189       if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5190         loc = &h->call_fp_stub;
5191       else
5192         loc = &h->call_stub;
5193
5194       /* If we already have an appropriate stub for this function, we
5195          don't need another one, so we can discard this one.  Since
5196          this function is called before the linker maps input sections
5197          to output sections, we can easily discard it by setting the
5198          SEC_EXCLUDE flag.  We can also discard this section if we
5199          happen to already know that this is a mips16 function; it is
5200          not necessary to check this here, as it is checked later, but
5201          it is slightly faster to check now.  */
5202       if (*loc != NULL || h->root.other == STO_MIPS16)
5203         {
5204           sec->flags |= SEC_EXCLUDE;
5205           return TRUE;
5206         }
5207
5208       *loc = sec;
5209       mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5210     }
5211
5212   if (dynobj == NULL)
5213     {
5214       sgot = NULL;
5215       g = NULL;
5216     }
5217   else
5218     {
5219       sgot = mips_elf_got_section (dynobj, FALSE);
5220       if (sgot == NULL)
5221         g = NULL;
5222       else
5223         {
5224           BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
5225           g = mips_elf_section_data (sgot)->u.got_info;
5226           BFD_ASSERT (g != NULL);
5227         }
5228     }
5229
5230   sreloc = NULL;
5231   bed = get_elf_backend_data (abfd);
5232   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5233   for (rel = relocs; rel < rel_end; ++rel)
5234     {
5235       unsigned long r_symndx;
5236       unsigned int r_type;
5237       struct elf_link_hash_entry *h;
5238
5239       r_symndx = ELF_R_SYM (abfd, rel->r_info);
5240       r_type = ELF_R_TYPE (abfd, rel->r_info);
5241
5242       if (r_symndx < extsymoff)
5243         h = NULL;
5244       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5245         {
5246           (*_bfd_error_handler)
5247             (_("%s: Malformed reloc detected for section %s"),
5248              bfd_archive_filename (abfd), name);
5249           bfd_set_error (bfd_error_bad_value);
5250           return FALSE;
5251         }
5252       else
5253         {
5254           h = sym_hashes[r_symndx - extsymoff];
5255
5256           /* This may be an indirect symbol created because of a version.  */
5257           if (h != NULL)
5258             {
5259               while (h->root.type == bfd_link_hash_indirect)
5260                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5261             }
5262         }
5263
5264       /* Some relocs require a global offset table.  */
5265       if (dynobj == NULL || sgot == NULL)
5266         {
5267           switch (r_type)
5268             {
5269             case R_MIPS_GOT16:
5270             case R_MIPS_CALL16:
5271             case R_MIPS_CALL_HI16:
5272             case R_MIPS_CALL_LO16:
5273             case R_MIPS_GOT_HI16:
5274             case R_MIPS_GOT_LO16:
5275             case R_MIPS_GOT_PAGE:
5276             case R_MIPS_GOT_OFST:
5277             case R_MIPS_GOT_DISP:
5278               if (dynobj == NULL)
5279                 elf_hash_table (info)->dynobj = dynobj = abfd;
5280               if (! mips_elf_create_got_section (dynobj, info, FALSE))
5281                 return FALSE;
5282               g = mips_elf_got_info (dynobj, &sgot);
5283               break;
5284
5285             case R_MIPS_32:
5286             case R_MIPS_REL32:
5287             case R_MIPS_64:
5288               if (dynobj == NULL
5289                   && (info->shared || h != NULL)
5290                   && (sec->flags & SEC_ALLOC) != 0)
5291                 elf_hash_table (info)->dynobj = dynobj = abfd;
5292               break;
5293
5294             default:
5295               break;
5296             }
5297         }
5298
5299       if (!h && (r_type == R_MIPS_CALL_LO16
5300                  || r_type == R_MIPS_GOT_LO16
5301                  || r_type == R_MIPS_GOT_DISP))
5302         {
5303           /* We may need a local GOT entry for this relocation.  We
5304              don't count R_MIPS_GOT_PAGE because we can estimate the
5305              maximum number of pages needed by looking at the size of
5306              the segment.  Similar comments apply to R_MIPS_GOT16 and
5307              R_MIPS_CALL16.  We don't count R_MIPS_GOT_HI16, or
5308              R_MIPS_CALL_HI16 because these are always followed by an
5309              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
5310           if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
5311                                                   rel->r_addend, g))
5312             return FALSE;
5313         }
5314
5315       switch (r_type)
5316         {
5317         case R_MIPS_CALL16:
5318           if (h == NULL)
5319             {
5320               (*_bfd_error_handler)
5321                 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5322                  bfd_archive_filename (abfd), (unsigned long) rel->r_offset);
5323               bfd_set_error (bfd_error_bad_value);
5324               return FALSE;
5325             }
5326           /* Fall through.  */
5327
5328         case R_MIPS_CALL_HI16:
5329         case R_MIPS_CALL_LO16:
5330           if (h != NULL)
5331             {
5332               /* This symbol requires a global offset table entry.  */
5333               if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5334                 return FALSE;
5335
5336               /* We need a stub, not a plt entry for the undefined
5337                  function.  But we record it as if it needs plt.  See
5338                  elf_adjust_dynamic_symbol in elflink.h.  */
5339               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
5340               h->type = STT_FUNC;
5341             }
5342           break;
5343
5344         case R_MIPS_GOT_PAGE:
5345           /* If this is a global, overridable symbol, GOT_PAGE will
5346              decay to GOT_DISP, so we'll need a GOT entry for it.  */
5347           if (h == NULL)
5348             break;
5349           else
5350             {
5351               struct mips_elf_link_hash_entry *hmips =
5352                 (struct mips_elf_link_hash_entry *) h;
5353
5354               while (hmips->root.root.type == bfd_link_hash_indirect
5355                      || hmips->root.root.type == bfd_link_hash_warning)
5356                 hmips = (struct mips_elf_link_hash_entry *)
5357                   hmips->root.root.u.i.link;
5358
5359               if ((hmips->root.root.type == bfd_link_hash_defined
5360                    || hmips->root.root.type == bfd_link_hash_defweak)
5361                   && hmips->root.root.u.def.section
5362                   && ! (info->shared && ! info->symbolic
5363                         && ! (hmips->root.elf_link_hash_flags
5364                               & ELF_LINK_FORCED_LOCAL))
5365                   /* If we've encountered any other relocation
5366                      referencing the symbol, we'll have marked it as
5367                      dynamic, and, even though we might be able to get
5368                      rid of the GOT entry should we know for sure all
5369                      previous relocations were GOT_PAGE ones, at this
5370                      point we can't tell, so just keep using the
5371                      symbol as dynamic.  This is very important in the
5372                      multi-got case, since we don't decide whether to
5373                      decay GOT_PAGE to GOT_DISP on a per-GOT basis: if
5374                      the symbol is dynamic, we'll need a GOT entry for
5375                      every GOT in which the symbol is referenced with
5376                      a GOT_PAGE relocation.  */
5377                   && hmips->root.dynindx == -1)
5378                 break;
5379             }
5380           /* Fall through.  */
5381
5382         case R_MIPS_GOT16:
5383         case R_MIPS_GOT_HI16:
5384         case R_MIPS_GOT_LO16:
5385         case R_MIPS_GOT_DISP:
5386           /* This symbol requires a global offset table entry.  */
5387           if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g))
5388             return FALSE;
5389           break;
5390
5391         case R_MIPS_32:
5392         case R_MIPS_REL32:
5393         case R_MIPS_64:
5394           if ((info->shared || h != NULL)
5395               && (sec->flags & SEC_ALLOC) != 0)
5396             {
5397               if (sreloc == NULL)
5398                 {
5399                   sreloc = mips_elf_rel_dyn_section (dynobj, TRUE);
5400                   if (sreloc == NULL)
5401                     return FALSE;
5402                 }
5403 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5404               if (info->shared)
5405                 {
5406                   /* When creating a shared object, we must copy these
5407                      reloc types into the output file as R_MIPS_REL32
5408                      relocs.  We make room for this reloc in the
5409                      .rel.dyn reloc section.  */
5410                   mips_elf_allocate_dynamic_relocations (dynobj, 1);
5411                   if ((sec->flags & MIPS_READONLY_SECTION)
5412                       == MIPS_READONLY_SECTION)
5413                     /* We tell the dynamic linker that there are
5414                        relocations against the text segment.  */
5415                     info->flags |= DF_TEXTREL;
5416                 }
5417               else
5418                 {
5419                   struct mips_elf_link_hash_entry *hmips;
5420
5421                   /* We only need to copy this reloc if the symbol is
5422                      defined in a dynamic object.  */
5423                   hmips = (struct mips_elf_link_hash_entry *) h;
5424                   ++hmips->possibly_dynamic_relocs;
5425                   if ((sec->flags & MIPS_READONLY_SECTION)
5426                       == MIPS_READONLY_SECTION)
5427                     /* We need it to tell the dynamic linker if there
5428                        are relocations against the text segment.  */
5429                     hmips->readonly_reloc = TRUE;
5430                 }
5431
5432               /* Even though we don't directly need a GOT entry for
5433                  this symbol, a symbol must have a dynamic symbol
5434                  table index greater that DT_MIPS_GOTSYM if there are
5435                  dynamic relocations against it.  */
5436               if (h != NULL)
5437                 {
5438                   if (dynobj == NULL)
5439                     elf_hash_table (info)->dynobj = dynobj = abfd;
5440                   if (! mips_elf_create_got_section (dynobj, info, TRUE))
5441                     return FALSE;
5442                   g = mips_elf_got_info (dynobj, &sgot);
5443                   if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5444                     return FALSE;
5445                 }
5446             }
5447
5448           if (SGI_COMPAT (abfd))
5449             mips_elf_hash_table (info)->compact_rel_size +=
5450               sizeof (Elf32_External_crinfo);
5451           break;
5452
5453         case R_MIPS_26:
5454         case R_MIPS_GPREL16:
5455         case R_MIPS_LITERAL:
5456         case R_MIPS_GPREL32:
5457           if (SGI_COMPAT (abfd))
5458             mips_elf_hash_table (info)->compact_rel_size +=
5459               sizeof (Elf32_External_crinfo);
5460           break;
5461
5462           /* This relocation describes the C++ object vtable hierarchy.
5463              Reconstruct it for later use during GC.  */
5464         case R_MIPS_GNU_VTINHERIT:
5465           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5466             return FALSE;
5467           break;
5468
5469           /* This relocation describes which C++ vtable entries are actually
5470              used.  Record for later use during GC.  */
5471         case R_MIPS_GNU_VTENTRY:
5472           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
5473             return FALSE;
5474           break;
5475
5476         default:
5477           break;
5478         }
5479
5480       /* We must not create a stub for a symbol that has relocations
5481          related to taking the function's address.  */
5482       switch (r_type)
5483         {
5484         default:
5485           if (h != NULL)
5486             {
5487               struct mips_elf_link_hash_entry *mh;
5488
5489               mh = (struct mips_elf_link_hash_entry *) h;
5490               mh->no_fn_stub = TRUE;
5491             }
5492           break;
5493         case R_MIPS_CALL16:
5494         case R_MIPS_CALL_HI16:
5495         case R_MIPS_CALL_LO16:
5496           break;
5497         }
5498
5499       /* If this reloc is not a 16 bit call, and it has a global
5500          symbol, then we will need the fn_stub if there is one.
5501          References from a stub section do not count.  */
5502       if (h != NULL
5503           && r_type != R_MIPS16_26
5504           && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
5505                       sizeof FN_STUB - 1) != 0
5506           && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
5507                       sizeof CALL_STUB - 1) != 0
5508           && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
5509                       sizeof CALL_FP_STUB - 1) != 0)
5510         {
5511           struct mips_elf_link_hash_entry *mh;
5512
5513           mh = (struct mips_elf_link_hash_entry *) h;
5514           mh->need_fn_stub = TRUE;
5515         }
5516     }
5517
5518   return TRUE;
5519 }
5520 \f
5521 bfd_boolean
5522 _bfd_mips_relax_section (abfd, sec, link_info, again)
5523      bfd *abfd;
5524      asection *sec;
5525      struct bfd_link_info *link_info;
5526      bfd_boolean *again;
5527 {
5528   Elf_Internal_Rela *internal_relocs;
5529   Elf_Internal_Rela *irel, *irelend;
5530   Elf_Internal_Shdr *symtab_hdr;
5531   bfd_byte *contents = NULL;
5532   bfd_byte *free_contents = NULL;
5533   size_t extsymoff;
5534   bfd_boolean changed_contents = FALSE;
5535   bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
5536   Elf_Internal_Sym *isymbuf = NULL;
5537
5538   /* We are not currently changing any sizes, so only one pass.  */
5539   *again = FALSE;
5540
5541   if (link_info->relocatable)
5542     return TRUE;
5543
5544   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, (PTR) NULL,
5545                                                (Elf_Internal_Rela *) NULL,
5546                                                link_info->keep_memory);
5547   if (internal_relocs == NULL)
5548     return TRUE;
5549
5550   irelend = internal_relocs + sec->reloc_count
5551     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
5552   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5553   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5554
5555   for (irel = internal_relocs; irel < irelend; irel++)
5556     {
5557       bfd_vma symval;
5558       bfd_signed_vma sym_offset;
5559       unsigned int r_type;
5560       unsigned long r_symndx;
5561       asection *sym_sec;
5562       unsigned long instruction;
5563
5564       /* Turn jalr into bgezal, and jr into beq, if they're marked
5565          with a JALR relocation, that indicate where they jump to.
5566          This saves some pipeline bubbles.  */
5567       r_type = ELF_R_TYPE (abfd, irel->r_info);
5568       if (r_type != R_MIPS_JALR)
5569         continue;
5570
5571       r_symndx = ELF_R_SYM (abfd, irel->r_info);
5572       /* Compute the address of the jump target.  */
5573       if (r_symndx >= extsymoff)
5574         {
5575           struct mips_elf_link_hash_entry *h
5576             = ((struct mips_elf_link_hash_entry *)
5577                elf_sym_hashes (abfd) [r_symndx - extsymoff]);
5578
5579           while (h->root.root.type == bfd_link_hash_indirect
5580                  || h->root.root.type == bfd_link_hash_warning)
5581             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5582
5583           /* If a symbol is undefined, or if it may be overridden,
5584              skip it.  */
5585           if (! ((h->root.root.type == bfd_link_hash_defined
5586                   || h->root.root.type == bfd_link_hash_defweak)
5587                  && h->root.root.u.def.section)
5588               || (link_info->shared && ! link_info->symbolic
5589                   && ! (h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)))
5590             continue;
5591
5592           sym_sec = h->root.root.u.def.section;
5593           if (sym_sec->output_section)
5594             symval = (h->root.root.u.def.value
5595                       + sym_sec->output_section->vma
5596                       + sym_sec->output_offset);
5597           else
5598             symval = h->root.root.u.def.value;
5599         }
5600       else
5601         {
5602           Elf_Internal_Sym *isym;
5603
5604           /* Read this BFD's symbols if we haven't done so already.  */
5605           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
5606             {
5607               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5608               if (isymbuf == NULL)
5609                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5610                                                 symtab_hdr->sh_info, 0,
5611                                                 NULL, NULL, NULL);
5612               if (isymbuf == NULL)
5613                 goto relax_return;
5614             }
5615
5616           isym = isymbuf + r_symndx;
5617           if (isym->st_shndx == SHN_UNDEF)
5618             continue;
5619           else if (isym->st_shndx == SHN_ABS)
5620             sym_sec = bfd_abs_section_ptr;
5621           else if (isym->st_shndx == SHN_COMMON)
5622             sym_sec = bfd_com_section_ptr;
5623           else
5624             sym_sec
5625               = bfd_section_from_elf_index (abfd, isym->st_shndx);
5626           symval = isym->st_value
5627             + sym_sec->output_section->vma
5628             + sym_sec->output_offset;
5629         }
5630
5631       /* Compute branch offset, from delay slot of the jump to the
5632          branch target.  */
5633       sym_offset = (symval + irel->r_addend)
5634         - (sec_start + irel->r_offset + 4);
5635
5636       /* Branch offset must be properly aligned.  */
5637       if ((sym_offset & 3) != 0)
5638         continue;
5639
5640       sym_offset >>= 2;
5641
5642       /* Check that it's in range.  */
5643       if (sym_offset < -0x8000 || sym_offset >= 0x8000)
5644         continue;
5645
5646       /* Get the section contents if we haven't done so already.  */
5647       if (contents == NULL)
5648         {
5649           /* Get cached copy if it exists.  */
5650           if (elf_section_data (sec)->this_hdr.contents != NULL)
5651             contents = elf_section_data (sec)->this_hdr.contents;
5652           else
5653             {
5654               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
5655               if (contents == NULL)
5656                 goto relax_return;
5657
5658               free_contents = contents;
5659               if (! bfd_get_section_contents (abfd, sec, contents,
5660                                               (file_ptr) 0, sec->_raw_size))
5661                 goto relax_return;
5662             }
5663         }
5664
5665       instruction = bfd_get_32 (abfd, contents + irel->r_offset);
5666
5667       /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
5668       if ((instruction & 0xfc1fffff) == 0x0000f809)
5669         instruction = 0x04110000;
5670       /* If it was jr <reg>, turn it into b <target>.  */
5671       else if ((instruction & 0xfc1fffff) == 0x00000008)
5672         instruction = 0x10000000;
5673       else
5674         continue;
5675
5676       instruction |= (sym_offset & 0xffff);
5677       bfd_put_32 (abfd, instruction, contents + irel->r_offset);
5678       changed_contents = TRUE;
5679     }
5680
5681   if (contents != NULL
5682       && elf_section_data (sec)->this_hdr.contents != contents)
5683     {
5684       if (!changed_contents && !link_info->keep_memory)
5685         free (contents);
5686       else
5687         {
5688           /* Cache the section contents for elf_link_input_bfd.  */
5689           elf_section_data (sec)->this_hdr.contents = contents;
5690         }
5691     }
5692   return TRUE;
5693
5694  relax_return:
5695   if (free_contents != NULL)
5696     free (free_contents);
5697   return FALSE;
5698 }
5699 \f
5700 /* Adjust a symbol defined by a dynamic object and referenced by a
5701    regular object.  The current definition is in some section of the
5702    dynamic object, but we're not including those sections.  We have to
5703    change the definition to something the rest of the link can
5704    understand.  */
5705
5706 bfd_boolean
5707 _bfd_mips_elf_adjust_dynamic_symbol (info, h)
5708      struct bfd_link_info *info;
5709      struct elf_link_hash_entry *h;
5710 {
5711   bfd *dynobj;
5712   struct mips_elf_link_hash_entry *hmips;
5713   asection *s;
5714
5715   dynobj = elf_hash_table (info)->dynobj;
5716
5717   /* Make sure we know what is going on here.  */
5718   BFD_ASSERT (dynobj != NULL
5719               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
5720                   || h->weakdef != NULL
5721                   || ((h->elf_link_hash_flags
5722                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5723                       && (h->elf_link_hash_flags
5724                           & ELF_LINK_HASH_REF_REGULAR) != 0
5725                       && (h->elf_link_hash_flags
5726                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
5727
5728   /* If this symbol is defined in a dynamic object, we need to copy
5729      any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5730      file.  */
5731   hmips = (struct mips_elf_link_hash_entry *) h;
5732   if (! info->relocatable
5733       && hmips->possibly_dynamic_relocs != 0
5734       && (h->root.type == bfd_link_hash_defweak
5735           || (h->elf_link_hash_flags
5736               & ELF_LINK_HASH_DEF_REGULAR) == 0))
5737     {
5738       mips_elf_allocate_dynamic_relocations (dynobj,
5739                                              hmips->possibly_dynamic_relocs);
5740       if (hmips->readonly_reloc)
5741         /* We tell the dynamic linker that there are relocations
5742            against the text segment.  */
5743         info->flags |= DF_TEXTREL;
5744     }
5745
5746   /* For a function, create a stub, if allowed.  */
5747   if (! hmips->no_fn_stub
5748       && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
5749     {
5750       if (! elf_hash_table (info)->dynamic_sections_created)
5751         return TRUE;
5752
5753       /* If this symbol is not defined in a regular file, then set
5754          the symbol to the stub location.  This is required to make
5755          function pointers compare as equal between the normal
5756          executable and the shared library.  */
5757       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
5758         {
5759           /* We need .stub section.  */
5760           s = bfd_get_section_by_name (dynobj,
5761                                        MIPS_ELF_STUB_SECTION_NAME (dynobj));
5762           BFD_ASSERT (s != NULL);
5763
5764           h->root.u.def.section = s;
5765           h->root.u.def.value = s->_raw_size;
5766
5767           /* XXX Write this stub address somewhere.  */
5768           h->plt.offset = s->_raw_size;
5769
5770           /* Make room for this stub code.  */
5771           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
5772
5773           /* The last half word of the stub will be filled with the index
5774              of this symbol in .dynsym section.  */
5775           return TRUE;
5776         }
5777     }
5778   else if ((h->type == STT_FUNC)
5779            && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
5780     {
5781       /* This will set the entry for this symbol in the GOT to 0, and
5782          the dynamic linker will take care of this.  */
5783       h->root.u.def.value = 0;
5784       return TRUE;
5785     }
5786
5787   /* If this is a weak symbol, and there is a real definition, the
5788      processor independent code will have arranged for us to see the
5789      real definition first, and we can just use the same value.  */
5790   if (h->weakdef != NULL)
5791     {
5792       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
5793                   || h->weakdef->root.type == bfd_link_hash_defweak);
5794       h->root.u.def.section = h->weakdef->root.u.def.section;
5795       h->root.u.def.value = h->weakdef->root.u.def.value;
5796       return TRUE;
5797     }
5798
5799   /* This is a reference to a symbol defined by a dynamic object which
5800      is not a function.  */
5801
5802   return TRUE;
5803 }
5804 \f
5805 /* This function is called after all the input files have been read,
5806    and the input sections have been assigned to output sections.  We
5807    check for any mips16 stub sections that we can discard.  */
5808
5809 bfd_boolean
5810 _bfd_mips_elf_always_size_sections (output_bfd, info)
5811      bfd *output_bfd;
5812      struct bfd_link_info *info;
5813 {
5814   asection *ri;
5815
5816   bfd *dynobj;
5817   asection *s;
5818   struct mips_got_info *g;
5819   int i;
5820   bfd_size_type loadable_size = 0;
5821   bfd_size_type local_gotno;
5822   bfd *sub;
5823
5824   /* The .reginfo section has a fixed size.  */
5825   ri = bfd_get_section_by_name (output_bfd, ".reginfo");
5826   if (ri != NULL)
5827     bfd_set_section_size (output_bfd, ri,
5828                           (bfd_size_type) sizeof (Elf32_External_RegInfo));
5829
5830   if (! (info->relocatable
5831          || ! mips_elf_hash_table (info)->mips16_stubs_seen))
5832     mips_elf_link_hash_traverse (mips_elf_hash_table (info),
5833                                  mips_elf_check_mips16_stubs,
5834                                  (PTR) NULL);
5835
5836   dynobj = elf_hash_table (info)->dynobj;
5837   if (dynobj == NULL)
5838     /* Relocatable links don't have it.  */
5839     return TRUE;
5840
5841   g = mips_elf_got_info (dynobj, &s);
5842   if (s == NULL)
5843     return TRUE;
5844
5845   /* Calculate the total loadable size of the output.  That
5846      will give us the maximum number of GOT_PAGE entries
5847      required.  */
5848   for (sub = info->input_bfds; sub; sub = sub->link_next)
5849     {
5850       asection *subsection;
5851
5852       for (subsection = sub->sections;
5853            subsection;
5854            subsection = subsection->next)
5855         {
5856           if ((subsection->flags & SEC_ALLOC) == 0)
5857             continue;
5858           loadable_size += ((subsection->_raw_size + 0xf)
5859                             &~ (bfd_size_type) 0xf);
5860         }
5861     }
5862
5863   /* There has to be a global GOT entry for every symbol with
5864      a dynamic symbol table index of DT_MIPS_GOTSYM or
5865      higher.  Therefore, it make sense to put those symbols
5866      that need GOT entries at the end of the symbol table.  We
5867      do that here.  */
5868   if (! mips_elf_sort_hash_table (info, 1))
5869     return FALSE;
5870
5871   if (g->global_gotsym != NULL)
5872     i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
5873   else
5874     /* If there are no global symbols, or none requiring
5875        relocations, then GLOBAL_GOTSYM will be NULL.  */
5876     i = 0;
5877
5878   /* In the worst case, we'll get one stub per dynamic symbol, plus
5879      one to account for the dummy entry at the end required by IRIX
5880      rld.  */
5881   loadable_size += MIPS_FUNCTION_STUB_SIZE * (i + 1);
5882
5883   /* Assume there are two loadable segments consisting of
5884      contiguous sections.  Is 5 enough?  */
5885   local_gotno = (loadable_size >> 16) + 5;
5886
5887   g->local_gotno += local_gotno;
5888   s->_raw_size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
5889
5890   g->global_gotno = i;
5891   s->_raw_size += i * MIPS_ELF_GOT_SIZE (output_bfd);
5892
5893   if (s->_raw_size > MIPS_ELF_GOT_MAX_SIZE (output_bfd)
5894       && ! mips_elf_multi_got (output_bfd, info, g, s, local_gotno))
5895     return FALSE;
5896
5897   return TRUE;
5898 }
5899
5900 /* Set the sizes of the dynamic sections.  */
5901
5902 bfd_boolean
5903 _bfd_mips_elf_size_dynamic_sections (output_bfd, info)
5904      bfd *output_bfd;
5905      struct bfd_link_info *info;
5906 {
5907   bfd *dynobj;
5908   asection *s;
5909   bfd_boolean reltext;
5910
5911   dynobj = elf_hash_table (info)->dynobj;
5912   BFD_ASSERT (dynobj != NULL);
5913
5914   if (elf_hash_table (info)->dynamic_sections_created)
5915     {
5916       /* Set the contents of the .interp section to the interpreter.  */
5917       if (! info->shared)
5918         {
5919           s = bfd_get_section_by_name (dynobj, ".interp");
5920           BFD_ASSERT (s != NULL);
5921           s->_raw_size
5922             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
5923           s->contents
5924             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
5925         }
5926     }
5927
5928   /* The check_relocs and adjust_dynamic_symbol entry points have
5929      determined the sizes of the various dynamic sections.  Allocate
5930      memory for them.  */
5931   reltext = FALSE;
5932   for (s = dynobj->sections; s != NULL; s = s->next)
5933     {
5934       const char *name;
5935       bfd_boolean strip;
5936
5937       /* It's OK to base decisions on the section name, because none
5938          of the dynobj section names depend upon the input files.  */
5939       name = bfd_get_section_name (dynobj, s);
5940
5941       if ((s->flags & SEC_LINKER_CREATED) == 0)
5942         continue;
5943
5944       strip = FALSE;
5945
5946       if (strncmp (name, ".rel", 4) == 0)
5947         {
5948           if (s->_raw_size == 0)
5949             {
5950               /* We only strip the section if the output section name
5951                  has the same name.  Otherwise, there might be several
5952                  input sections for this output section.  FIXME: This
5953                  code is probably not needed these days anyhow, since
5954                  the linker now does not create empty output sections.  */
5955               if (s->output_section != NULL
5956                   && strcmp (name,
5957                              bfd_get_section_name (s->output_section->owner,
5958                                                    s->output_section)) == 0)
5959                 strip = TRUE;
5960             }
5961           else
5962             {
5963               const char *outname;
5964               asection *target;
5965
5966               /* If this relocation section applies to a read only
5967                  section, then we probably need a DT_TEXTREL entry.
5968                  If the relocation section is .rel.dyn, we always
5969                  assert a DT_TEXTREL entry rather than testing whether
5970                  there exists a relocation to a read only section or
5971                  not.  */
5972               outname = bfd_get_section_name (output_bfd,
5973                                               s->output_section);
5974               target = bfd_get_section_by_name (output_bfd, outname + 4);
5975               if ((target != NULL
5976                    && (target->flags & SEC_READONLY) != 0
5977                    && (target->flags & SEC_ALLOC) != 0)
5978                   || strcmp (outname, ".rel.dyn") == 0)
5979                 reltext = TRUE;
5980
5981               /* We use the reloc_count field as a counter if we need
5982                  to copy relocs into the output file.  */
5983               if (strcmp (name, ".rel.dyn") != 0)
5984                 s->reloc_count = 0;
5985
5986               /* If combreloc is enabled, elf_link_sort_relocs() will
5987                  sort relocations, but in a different way than we do,
5988                  and before we're done creating relocations.  Also, it
5989                  will move them around between input sections'
5990                  relocation's contents, so our sorting would be
5991                  broken, so don't let it run.  */
5992               info->combreloc = 0;
5993             }
5994         }
5995       else if (strncmp (name, ".got", 4) == 0)
5996         {
5997           /* _bfd_mips_elf_always_size_sections() has already done
5998              most of the work, but some symbols may have been mapped
5999              to versions that we must now resolve in the got_entries
6000              hash tables.  */
6001           struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
6002           struct mips_got_info *g = gg;
6003           struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
6004           unsigned int needed_relocs = 0;
6005
6006           if (gg->next)
6007             {
6008               set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
6009               set_got_offset_arg.info = info;
6010
6011               mips_elf_resolve_final_got_entries (gg);
6012               for (g = gg->next; g && g->next != gg; g = g->next)
6013                 {
6014                   unsigned int save_assign;
6015
6016                   mips_elf_resolve_final_got_entries (g);
6017
6018                   /* Assign offsets to global GOT entries.  */
6019                   save_assign = g->assigned_gotno;
6020                   g->assigned_gotno = g->local_gotno;
6021                   set_got_offset_arg.g = g;
6022                   set_got_offset_arg.needed_relocs = 0;
6023                   htab_traverse (g->got_entries,
6024                                  mips_elf_set_global_got_offset,
6025                                  &set_got_offset_arg);
6026                   needed_relocs += set_got_offset_arg.needed_relocs;
6027                   BFD_ASSERT (g->assigned_gotno - g->local_gotno
6028                               <= g->global_gotno);
6029
6030                   g->assigned_gotno = save_assign;
6031                   if (info->shared)
6032                     {
6033                       needed_relocs += g->local_gotno - g->assigned_gotno;
6034                       BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
6035                                   + g->next->global_gotno
6036                                   + MIPS_RESERVED_GOTNO);
6037                     }
6038                 }
6039
6040               if (needed_relocs)
6041                 mips_elf_allocate_dynamic_relocations (dynobj, needed_relocs);
6042             }
6043         }
6044       else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
6045         {
6046           /* IRIX rld assumes that the function stub isn't at the end
6047              of .text section. So put a dummy. XXX  */
6048           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
6049         }
6050       else if (! info->shared
6051                && ! mips_elf_hash_table (info)->use_rld_obj_head
6052                && strncmp (name, ".rld_map", 8) == 0)
6053         {
6054           /* We add a room for __rld_map. It will be filled in by the
6055              rtld to contain a pointer to the _r_debug structure.  */
6056           s->_raw_size += 4;
6057         }
6058       else if (SGI_COMPAT (output_bfd)
6059                && strncmp (name, ".compact_rel", 12) == 0)
6060         s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
6061       else if (strcmp (name, ".msym") == 0)
6062         s->_raw_size = (sizeof (Elf32_External_Msym)
6063                         * (elf_hash_table (info)->dynsymcount
6064                            + bfd_count_sections (output_bfd)));
6065       else if (strncmp (name, ".init", 5) != 0)
6066         {
6067           /* It's not one of our sections, so don't allocate space.  */
6068           continue;
6069         }
6070
6071       if (strip)
6072         {
6073           _bfd_strip_section_from_output (info, s);
6074           continue;
6075         }
6076
6077       /* Allocate memory for the section contents.  */
6078       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
6079       if (s->contents == NULL && s->_raw_size != 0)
6080         {
6081           bfd_set_error (bfd_error_no_memory);
6082           return FALSE;
6083         }
6084     }
6085
6086   if (elf_hash_table (info)->dynamic_sections_created)
6087     {
6088       /* Add some entries to the .dynamic section.  We fill in the
6089          values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6090          must add the entries now so that we get the correct size for
6091          the .dynamic section.  The DT_DEBUG entry is filled in by the
6092          dynamic linker and used by the debugger.  */
6093       if (! info->shared)
6094         {
6095           /* SGI object has the equivalence of DT_DEBUG in the
6096              DT_MIPS_RLD_MAP entry.  */
6097           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
6098             return FALSE;
6099           if (!SGI_COMPAT (output_bfd))
6100             {
6101               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6102                 return FALSE;
6103             }
6104         }
6105       else
6106         {
6107           /* Shared libraries on traditional mips have DT_DEBUG.  */
6108           if (!SGI_COMPAT (output_bfd))
6109             {
6110               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6111                 return FALSE;
6112             }
6113         }
6114
6115       if (reltext && SGI_COMPAT (output_bfd))
6116         info->flags |= DF_TEXTREL;
6117
6118       if ((info->flags & DF_TEXTREL) != 0)
6119         {
6120           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
6121             return FALSE;
6122         }
6123
6124       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
6125         return FALSE;
6126
6127       if (mips_elf_rel_dyn_section (dynobj, FALSE))
6128         {
6129           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
6130             return FALSE;
6131
6132           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
6133             return FALSE;
6134
6135           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
6136             return FALSE;
6137         }
6138
6139       if (SGI_COMPAT (output_bfd))
6140         {
6141           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICTNO, 0))
6142             return FALSE;
6143         }
6144
6145       if (SGI_COMPAT (output_bfd))
6146         {
6147           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLISTNO, 0))
6148             return FALSE;
6149         }
6150
6151       if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
6152         {
6153           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICT, 0))
6154             return FALSE;
6155
6156           s = bfd_get_section_by_name (dynobj, ".liblist");
6157           BFD_ASSERT (s != NULL);
6158
6159           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLIST, 0))
6160             return FALSE;
6161         }
6162
6163       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
6164         return FALSE;
6165
6166       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
6167         return FALSE;
6168
6169 #if 0
6170       /* Time stamps in executable files are a bad idea.  */
6171       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
6172         return FALSE;
6173 #endif
6174
6175 #if 0 /* FIXME  */
6176       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
6177         return FALSE;
6178 #endif
6179
6180 #if 0 /* FIXME  */
6181       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
6182         return FALSE;
6183 #endif
6184
6185       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
6186         return FALSE;
6187
6188       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
6189         return FALSE;
6190
6191       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
6192         return FALSE;
6193
6194       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
6195         return FALSE;
6196
6197       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
6198         return FALSE;
6199
6200       if (IRIX_COMPAT (dynobj) == ict_irix5
6201           && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
6202         return FALSE;
6203
6204       if (IRIX_COMPAT (dynobj) == ict_irix6
6205           && (bfd_get_section_by_name
6206               (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
6207           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
6208         return FALSE;
6209
6210       if (bfd_get_section_by_name (dynobj, ".msym")
6211           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_MSYM, 0))
6212         return FALSE;
6213     }
6214
6215   return TRUE;
6216 }
6217 \f
6218 /* Relocate a MIPS ELF section.  */
6219
6220 bfd_boolean
6221 _bfd_mips_elf_relocate_section (output_bfd, info, input_bfd, input_section,
6222                                 contents, relocs, local_syms, local_sections)
6223      bfd *output_bfd;
6224      struct bfd_link_info *info;
6225      bfd *input_bfd;
6226      asection *input_section;
6227      bfd_byte *contents;
6228      Elf_Internal_Rela *relocs;
6229      Elf_Internal_Sym *local_syms;
6230      asection **local_sections;
6231 {
6232   Elf_Internal_Rela *rel;
6233   const Elf_Internal_Rela *relend;
6234   bfd_vma addend = 0;
6235   bfd_boolean use_saved_addend_p = FALSE;
6236   struct elf_backend_data *bed;
6237
6238   bed = get_elf_backend_data (output_bfd);
6239   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6240   for (rel = relocs; rel < relend; ++rel)
6241     {
6242       const char *name;
6243       bfd_vma value;
6244       reloc_howto_type *howto;
6245       bfd_boolean require_jalx;
6246       /* TRUE if the relocation is a RELA relocation, rather than a
6247          REL relocation.  */
6248       bfd_boolean rela_relocation_p = TRUE;
6249       unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6250       const char * msg = (const char *) NULL;
6251
6252       /* Find the relocation howto for this relocation.  */
6253       if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
6254         {
6255           /* Some 32-bit code uses R_MIPS_64.  In particular, people use
6256              64-bit code, but make sure all their addresses are in the
6257              lowermost or uppermost 32-bit section of the 64-bit address
6258              space.  Thus, when they use an R_MIPS_64 they mean what is
6259              usually meant by R_MIPS_32, with the exception that the
6260              stored value is sign-extended to 64 bits.  */
6261           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
6262
6263           /* On big-endian systems, we need to lie about the position
6264              of the reloc.  */
6265           if (bfd_big_endian (input_bfd))
6266             rel->r_offset += 4;
6267         }
6268       else
6269         /* NewABI defaults to RELA relocations.  */
6270         howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
6271                                          NEWABI_P (input_bfd)
6272                                          && (MIPS_RELOC_RELA_P
6273                                              (input_bfd, input_section,
6274                                               rel - relocs)));
6275
6276       if (!use_saved_addend_p)
6277         {
6278           Elf_Internal_Shdr *rel_hdr;
6279
6280           /* If these relocations were originally of the REL variety,
6281              we must pull the addend out of the field that will be
6282              relocated.  Otherwise, we simply use the contents of the
6283              RELA relocation.  To determine which flavor or relocation
6284              this is, we depend on the fact that the INPUT_SECTION's
6285              REL_HDR is read before its REL_HDR2.  */
6286           rel_hdr = &elf_section_data (input_section)->rel_hdr;
6287           if ((size_t) (rel - relocs)
6288               >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6289             rel_hdr = elf_section_data (input_section)->rel_hdr2;
6290           if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6291             {
6292               /* Note that this is a REL relocation.  */
6293               rela_relocation_p = FALSE;
6294
6295               /* Get the addend, which is stored in the input file.  */
6296               addend = mips_elf_obtain_contents (howto, rel, input_bfd,
6297                                                  contents);
6298               addend &= howto->src_mask;
6299               addend <<= howto->rightshift;
6300
6301               /* For some kinds of relocations, the ADDEND is a
6302                  combination of the addend stored in two different
6303                  relocations.   */
6304               if (r_type == R_MIPS_HI16
6305                   || r_type == R_MIPS_GNU_REL_HI16
6306                   || (r_type == R_MIPS_GOT16
6307                       && mips_elf_local_relocation_p (input_bfd, rel,
6308                                                       local_sections, FALSE)))
6309                 {
6310                   bfd_vma l;
6311                   const Elf_Internal_Rela *lo16_relocation;
6312                   reloc_howto_type *lo16_howto;
6313                   unsigned int lo;
6314
6315                   /* The combined value is the sum of the HI16 addend,
6316                      left-shifted by sixteen bits, and the LO16
6317                      addend, sign extended.  (Usually, the code does
6318                      a `lui' of the HI16 value, and then an `addiu' of
6319                      the LO16 value.)
6320
6321                      Scan ahead to find a matching LO16 relocation.  */
6322                   if (r_type == R_MIPS_GNU_REL_HI16)
6323                     lo = R_MIPS_GNU_REL_LO16;
6324                   else
6325                     lo = R_MIPS_LO16;
6326                   lo16_relocation = mips_elf_next_relocation (input_bfd, lo,
6327                                                               rel, relend);
6328                   if (lo16_relocation == NULL)
6329                     return FALSE;
6330
6331                   /* Obtain the addend kept there.  */
6332                   lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, lo, FALSE);
6333                   l = mips_elf_obtain_contents (lo16_howto, lo16_relocation,
6334                                                 input_bfd, contents);
6335                   l &= lo16_howto->src_mask;
6336                   l <<= lo16_howto->rightshift;
6337                   l = _bfd_mips_elf_sign_extend (l, 16);
6338
6339                   addend <<= 16;
6340
6341                   /* Compute the combined addend.  */
6342                   addend += l;
6343
6344                   /* If PC-relative, subtract the difference between the
6345                      address of the LO part of the reloc and the address of
6346                      the HI part.  The relocation is relative to the LO
6347                      part, but mips_elf_calculate_relocation() doesn't
6348                      know its address or the difference from the HI part, so
6349                      we subtract that difference here.  See also the
6350                      comment in mips_elf_calculate_relocation().  */
6351                   if (r_type == R_MIPS_GNU_REL_HI16)
6352                     addend -= (lo16_relocation->r_offset - rel->r_offset);
6353                 }
6354               else if (r_type == R_MIPS16_GPREL)
6355                 {
6356                   /* The addend is scrambled in the object file.  See
6357                      mips_elf_perform_relocation for details on the
6358                      format.  */
6359                   addend = (((addend & 0x1f0000) >> 5)
6360                             | ((addend & 0x7e00000) >> 16)
6361                             | (addend & 0x1f));
6362                 }
6363             }
6364           else
6365             addend = rel->r_addend;
6366         }
6367
6368       if (info->relocatable)
6369         {
6370           Elf_Internal_Sym *sym;
6371           unsigned long r_symndx;
6372
6373           if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
6374               && bfd_big_endian (input_bfd))
6375             rel->r_offset -= 4;
6376
6377           /* Since we're just relocating, all we need to do is copy
6378              the relocations back out to the object file, unless
6379              they're against a section symbol, in which case we need
6380              to adjust by the section offset, or unless they're GP
6381              relative in which case we need to adjust by the amount
6382              that we're adjusting GP in this relocatable object.  */
6383
6384           if (! mips_elf_local_relocation_p (input_bfd, rel, local_sections,
6385                                              FALSE))
6386             /* There's nothing to do for non-local relocations.  */
6387             continue;
6388
6389           if (r_type == R_MIPS16_GPREL
6390               || r_type == R_MIPS_GPREL16
6391               || r_type == R_MIPS_GPREL32
6392               || r_type == R_MIPS_LITERAL)
6393             addend -= (_bfd_get_gp_value (output_bfd)
6394                        - _bfd_get_gp_value (input_bfd));
6395
6396           r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
6397           sym = local_syms + r_symndx;
6398           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6399             /* Adjust the addend appropriately.  */
6400             addend += local_sections[r_symndx]->output_offset;
6401
6402           if (howto->partial_inplace)
6403             {
6404               /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6405                  then we only want to write out the high-order 16 bits.
6406                  The subsequent R_MIPS_LO16 will handle the low-order bits.
6407                */
6408               if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
6409                   || r_type == R_MIPS_GNU_REL_HI16)
6410                 addend = mips_elf_high (addend);
6411               else if (r_type == R_MIPS_HIGHER)
6412                 addend = mips_elf_higher (addend);
6413               else if (r_type == R_MIPS_HIGHEST)
6414                 addend = mips_elf_highest (addend);
6415             }
6416
6417           if (rela_relocation_p)
6418             /* If this is a RELA relocation, just update the addend.
6419                We have to cast away constness for REL.  */
6420             rel->r_addend = addend;
6421           else
6422             {
6423               /* Otherwise, we have to write the value back out.  Note
6424                  that we use the source mask, rather than the
6425                  destination mask because the place to which we are
6426                  writing will be source of the addend in the final
6427                  link.  */
6428               addend >>= howto->rightshift;
6429               addend &= howto->src_mask;
6430
6431               if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6432                 /* See the comment above about using R_MIPS_64 in the 32-bit
6433                    ABI.  Here, we need to update the addend.  It would be
6434                    possible to get away with just using the R_MIPS_32 reloc
6435                    but for endianness.  */
6436                 {
6437                   bfd_vma sign_bits;
6438                   bfd_vma low_bits;
6439                   bfd_vma high_bits;
6440
6441                   if (addend & ((bfd_vma) 1 << 31))
6442 #ifdef BFD64
6443                     sign_bits = ((bfd_vma) 1 << 32) - 1;
6444 #else
6445                     sign_bits = -1;
6446 #endif
6447                   else
6448                     sign_bits = 0;
6449
6450                   /* If we don't know that we have a 64-bit type,
6451                      do two separate stores.  */
6452                   if (bfd_big_endian (input_bfd))
6453                     {
6454                       /* Store the sign-bits (which are most significant)
6455                          first.  */
6456                       low_bits = sign_bits;
6457                       high_bits = addend;
6458                     }
6459                   else
6460                     {
6461                       low_bits = addend;
6462                       high_bits = sign_bits;
6463                     }
6464                   bfd_put_32 (input_bfd, low_bits,
6465                               contents + rel->r_offset);
6466                   bfd_put_32 (input_bfd, high_bits,
6467                               contents + rel->r_offset + 4);
6468                   continue;
6469                 }
6470
6471               if (! mips_elf_perform_relocation (info, howto, rel, addend,
6472                                                  input_bfd, input_section,
6473                                                  contents, FALSE))
6474                 return FALSE;
6475             }
6476
6477           /* Go on to the next relocation.  */
6478           continue;
6479         }
6480
6481       /* In the N32 and 64-bit ABIs there may be multiple consecutive
6482          relocations for the same offset.  In that case we are
6483          supposed to treat the output of each relocation as the addend
6484          for the next.  */
6485       if (rel + 1 < relend
6486           && rel->r_offset == rel[1].r_offset
6487           && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
6488         use_saved_addend_p = TRUE;
6489       else
6490         use_saved_addend_p = FALSE;
6491
6492       addend >>= howto->rightshift;
6493
6494       /* Figure out what value we are supposed to relocate.  */
6495       switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
6496                                              input_section, info, rel,
6497                                              addend, howto, local_syms,
6498                                              local_sections, &value,
6499                                              &name, &require_jalx,
6500                                              use_saved_addend_p))
6501         {
6502         case bfd_reloc_continue:
6503           /* There's nothing to do.  */
6504           continue;
6505
6506         case bfd_reloc_undefined:
6507           /* mips_elf_calculate_relocation already called the
6508              undefined_symbol callback.  There's no real point in
6509              trying to perform the relocation at this point, so we
6510              just skip ahead to the next relocation.  */
6511           continue;
6512
6513         case bfd_reloc_notsupported:
6514           msg = _("internal error: unsupported relocation error");
6515           info->callbacks->warning
6516             (info, msg, name, input_bfd, input_section, rel->r_offset);
6517           return FALSE;
6518
6519         case bfd_reloc_overflow:
6520           if (use_saved_addend_p)
6521             /* Ignore overflow until we reach the last relocation for
6522                a given location.  */
6523             ;
6524           else
6525             {
6526               BFD_ASSERT (name != NULL);
6527               if (! ((*info->callbacks->reloc_overflow)
6528                      (info, name, howto->name, (bfd_vma) 0,
6529                       input_bfd, input_section, rel->r_offset)))
6530                 return FALSE;
6531             }
6532           break;
6533
6534         case bfd_reloc_ok:
6535           break;
6536
6537         default:
6538           abort ();
6539           break;
6540         }
6541
6542       /* If we've got another relocation for the address, keep going
6543          until we reach the last one.  */
6544       if (use_saved_addend_p)
6545         {
6546           addend = value;
6547           continue;
6548         }
6549
6550       if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6551         /* See the comment above about using R_MIPS_64 in the 32-bit
6552            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
6553            that calculated the right value.  Now, however, we
6554            sign-extend the 32-bit result to 64-bits, and store it as a
6555            64-bit value.  We are especially generous here in that we
6556            go to extreme lengths to support this usage on systems with
6557            only a 32-bit VMA.  */
6558         {
6559           bfd_vma sign_bits;
6560           bfd_vma low_bits;
6561           bfd_vma high_bits;
6562
6563           if (value & ((bfd_vma) 1 << 31))
6564 #ifdef BFD64
6565             sign_bits = ((bfd_vma) 1 << 32) - 1;
6566 #else
6567             sign_bits = -1;
6568 #endif
6569           else
6570             sign_bits = 0;
6571
6572           /* If we don't know that we have a 64-bit type,
6573              do two separate stores.  */
6574           if (bfd_big_endian (input_bfd))
6575             {
6576               /* Undo what we did above.  */
6577               rel->r_offset -= 4;
6578               /* Store the sign-bits (which are most significant)
6579                  first.  */
6580               low_bits = sign_bits;
6581               high_bits = value;
6582             }
6583           else
6584             {
6585               low_bits = value;
6586               high_bits = sign_bits;
6587             }
6588           bfd_put_32 (input_bfd, low_bits,
6589                       contents + rel->r_offset);
6590           bfd_put_32 (input_bfd, high_bits,
6591                       contents + rel->r_offset + 4);
6592           continue;
6593         }
6594
6595       /* Actually perform the relocation.  */
6596       if (! mips_elf_perform_relocation (info, howto, rel, value,
6597                                          input_bfd, input_section,
6598                                          contents, require_jalx))
6599         return FALSE;
6600     }
6601
6602   return TRUE;
6603 }
6604 \f
6605 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6606    adjust it appropriately now.  */
6607
6608 static void
6609 mips_elf_irix6_finish_dynamic_symbol (abfd, name, sym)
6610      bfd *abfd ATTRIBUTE_UNUSED;
6611      const char *name;
6612      Elf_Internal_Sym *sym;
6613 {
6614   /* The linker script takes care of providing names and values for
6615      these, but we must place them into the right sections.  */
6616   static const char* const text_section_symbols[] = {
6617     "_ftext",
6618     "_etext",
6619     "__dso_displacement",
6620     "__elf_header",
6621     "__program_header_table",
6622     NULL
6623   };
6624
6625   static const char* const data_section_symbols[] = {
6626     "_fdata",
6627     "_edata",
6628     "_end",
6629     "_fbss",
6630     NULL
6631   };
6632
6633   const char* const *p;
6634   int i;
6635
6636   for (i = 0; i < 2; ++i)
6637     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
6638          *p;
6639          ++p)
6640       if (strcmp (*p, name) == 0)
6641         {
6642           /* All of these symbols are given type STT_SECTION by the
6643              IRIX6 linker.  */
6644           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6645
6646           /* The IRIX linker puts these symbols in special sections.  */
6647           if (i == 0)
6648             sym->st_shndx = SHN_MIPS_TEXT;
6649           else
6650             sym->st_shndx = SHN_MIPS_DATA;
6651
6652           break;
6653         }
6654 }
6655
6656 /* Finish up dynamic symbol handling.  We set the contents of various
6657    dynamic sections here.  */
6658
6659 bfd_boolean
6660 _bfd_mips_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
6661      bfd *output_bfd;
6662      struct bfd_link_info *info;
6663      struct elf_link_hash_entry *h;
6664      Elf_Internal_Sym *sym;
6665 {
6666   bfd *dynobj;
6667   bfd_vma gval;
6668   asection *sgot;
6669   asection *smsym;
6670   struct mips_got_info *g, *gg;
6671   const char *name;
6672   struct mips_elf_link_hash_entry *mh;
6673
6674   dynobj = elf_hash_table (info)->dynobj;
6675   gval = sym->st_value;
6676   mh = (struct mips_elf_link_hash_entry *) h;
6677
6678   if (h->plt.offset != (bfd_vma) -1)
6679     {
6680       asection *s;
6681       bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
6682
6683       /* This symbol has a stub.  Set it up.  */
6684
6685       BFD_ASSERT (h->dynindx != -1);
6686
6687       s = bfd_get_section_by_name (dynobj,
6688                                    MIPS_ELF_STUB_SECTION_NAME (dynobj));
6689       BFD_ASSERT (s != NULL);
6690
6691       /* FIXME: Can h->dynindex be more than 64K?  */
6692       if (h->dynindx & 0xffff0000)
6693         return FALSE;
6694
6695       /* Fill the stub.  */
6696       bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub);
6697       bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + 4);
6698       bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
6699       bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, stub + 12);
6700
6701       BFD_ASSERT (h->plt.offset <= s->_raw_size);
6702       memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
6703
6704       /* Mark the symbol as undefined.  plt.offset != -1 occurs
6705          only for the referenced symbol.  */
6706       sym->st_shndx = SHN_UNDEF;
6707
6708       /* The run-time linker uses the st_value field of the symbol
6709          to reset the global offset table entry for this external
6710          to its stub address when unlinking a shared object.  */
6711       gval = s->output_section->vma + s->output_offset + h->plt.offset;
6712       sym->st_value = gval;
6713     }
6714
6715   BFD_ASSERT (h->dynindx != -1
6716               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
6717
6718   sgot = mips_elf_got_section (dynobj, FALSE);
6719   BFD_ASSERT (sgot != NULL);
6720   BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6721   g = mips_elf_section_data (sgot)->u.got_info;
6722   BFD_ASSERT (g != NULL);
6723
6724   /* Run through the global symbol table, creating GOT entries for all
6725      the symbols that need them.  */
6726   if (g->global_gotsym != NULL
6727       && h->dynindx >= g->global_gotsym->dynindx)
6728     {
6729       bfd_vma offset;
6730       bfd_vma value;
6731
6732       if (sym->st_value)
6733         value = sym->st_value;
6734       else
6735         {
6736           /* For an entity defined in a shared object, this will be
6737              NULL.  (For functions in shared objects for
6738              which we have created stubs, ST_VALUE will be non-NULL.
6739              That's because such the functions are now no longer defined
6740              in a shared object.)  */
6741
6742           if ((info->shared && h->root.type == bfd_link_hash_undefined)
6743               || h->root.type == bfd_link_hash_undefweak)
6744             value = 0;
6745           else
6746             value = h->root.u.def.value;
6747         }
6748       offset = mips_elf_global_got_index (dynobj, output_bfd, h);
6749       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6750     }
6751
6752   if (g->next && h->dynindx != -1)
6753     {
6754       struct mips_got_entry e, *p;
6755       bfd_vma offset;
6756       bfd_vma value;
6757       Elf_Internal_Rela rel[3];
6758       bfd_vma addend = 0;
6759
6760       gg = g;
6761
6762       e.abfd = output_bfd;
6763       e.symndx = -1;
6764       e.d.h = (struct mips_elf_link_hash_entry *)h;
6765
6766       if (info->shared
6767           || h->root.type == bfd_link_hash_undefined
6768           || h->root.type == bfd_link_hash_undefweak)
6769         value = 0;
6770       else if (sym->st_value)
6771         value = sym->st_value;
6772       else
6773         value = h->root.u.def.value;
6774
6775       memset (rel, 0, sizeof (rel));
6776       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
6777
6778       for (g = g->next; g->next != gg; g = g->next)
6779         {
6780           if (g->got_entries
6781               && (p = (struct mips_got_entry *) htab_find (g->got_entries,
6782                                                            &e)))
6783             {
6784               offset = p->gotidx;
6785               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
6786
6787               MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6788
6789               if ((info->shared
6790                    || (elf_hash_table (info)->dynamic_sections_created
6791                        && p->d.h != NULL
6792                        && ((p->d.h->root.elf_link_hash_flags
6793                             & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
6794                        && ((p->d.h->root.elf_link_hash_flags
6795                             & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6796                   && ! (mips_elf_create_dynamic_relocation
6797                         (output_bfd, info, rel,
6798                          e.d.h, NULL, value, &addend, sgot)))
6799                 return FALSE;
6800               BFD_ASSERT (addend == 0);
6801             }
6802         }
6803     }
6804
6805   /* Create a .msym entry, if appropriate.  */
6806   smsym = bfd_get_section_by_name (dynobj, ".msym");
6807   if (smsym)
6808     {
6809       Elf32_Internal_Msym msym;
6810
6811       msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
6812       /* It is undocumented what the `1' indicates, but IRIX6 uses
6813          this value.  */
6814       msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
6815       bfd_mips_elf_swap_msym_out
6816         (dynobj, &msym,
6817          ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
6818     }
6819
6820   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
6821   name = h->root.root.string;
6822   if (strcmp (name, "_DYNAMIC") == 0
6823       || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
6824     sym->st_shndx = SHN_ABS;
6825   else if (strcmp (name, "_DYNAMIC_LINK") == 0
6826            || strcmp (name, "_DYNAMIC_LINKING") == 0)
6827     {
6828       sym->st_shndx = SHN_ABS;
6829       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6830       sym->st_value = 1;
6831     }
6832   else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
6833     {
6834       sym->st_shndx = SHN_ABS;
6835       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6836       sym->st_value = elf_gp (output_bfd);
6837     }
6838   else if (SGI_COMPAT (output_bfd))
6839     {
6840       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
6841           || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
6842         {
6843           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6844           sym->st_other = STO_PROTECTED;
6845           sym->st_value = 0;
6846           sym->st_shndx = SHN_MIPS_DATA;
6847         }
6848       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
6849         {
6850           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6851           sym->st_other = STO_PROTECTED;
6852           sym->st_value = mips_elf_hash_table (info)->procedure_count;
6853           sym->st_shndx = SHN_ABS;
6854         }
6855       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
6856         {
6857           if (h->type == STT_FUNC)
6858             sym->st_shndx = SHN_MIPS_TEXT;
6859           else if (h->type == STT_OBJECT)
6860             sym->st_shndx = SHN_MIPS_DATA;
6861         }
6862     }
6863
6864   /* Handle the IRIX6-specific symbols.  */
6865   if (IRIX_COMPAT (output_bfd) == ict_irix6)
6866     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
6867
6868   if (! info->shared)
6869     {
6870       if (! mips_elf_hash_table (info)->use_rld_obj_head
6871           && (strcmp (name, "__rld_map") == 0
6872               || strcmp (name, "__RLD_MAP") == 0))
6873         {
6874           asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
6875           BFD_ASSERT (s != NULL);
6876           sym->st_value = s->output_section->vma + s->output_offset;
6877           bfd_put_32 (output_bfd, (bfd_vma) 0, s->contents);
6878           if (mips_elf_hash_table (info)->rld_value == 0)
6879             mips_elf_hash_table (info)->rld_value = sym->st_value;
6880         }
6881       else if (mips_elf_hash_table (info)->use_rld_obj_head
6882                && strcmp (name, "__rld_obj_head") == 0)
6883         {
6884           /* IRIX6 does not use a .rld_map section.  */
6885           if (IRIX_COMPAT (output_bfd) == ict_irix5
6886               || IRIX_COMPAT (output_bfd) == ict_none)
6887             BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
6888                         != NULL);
6889           mips_elf_hash_table (info)->rld_value = sym->st_value;
6890         }
6891     }
6892
6893   /* If this is a mips16 symbol, force the value to be even.  */
6894   if (sym->st_other == STO_MIPS16
6895       && (sym->st_value & 1) != 0)
6896     --sym->st_value;
6897
6898   return TRUE;
6899 }
6900
6901 /* Finish up the dynamic sections.  */
6902
6903 bfd_boolean
6904 _bfd_mips_elf_finish_dynamic_sections (output_bfd, info)
6905      bfd *output_bfd;
6906      struct bfd_link_info *info;
6907 {
6908   bfd *dynobj;
6909   asection *sdyn;
6910   asection *sgot;
6911   struct mips_got_info *gg, *g;
6912
6913   dynobj = elf_hash_table (info)->dynobj;
6914
6915   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6916
6917   sgot = mips_elf_got_section (dynobj, FALSE);
6918   if (sgot == NULL)
6919     gg = g = NULL;
6920   else
6921     {
6922       BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6923       gg = mips_elf_section_data (sgot)->u.got_info;
6924       BFD_ASSERT (gg != NULL);
6925       g = mips_elf_got_for_ibfd (gg, output_bfd);
6926       BFD_ASSERT (g != NULL);
6927     }
6928
6929   if (elf_hash_table (info)->dynamic_sections_created)
6930     {
6931       bfd_byte *b;
6932
6933       BFD_ASSERT (sdyn != NULL);
6934       BFD_ASSERT (g != NULL);
6935
6936       for (b = sdyn->contents;
6937            b < sdyn->contents + sdyn->_raw_size;
6938            b += MIPS_ELF_DYN_SIZE (dynobj))
6939         {
6940           Elf_Internal_Dyn dyn;
6941           const char *name;
6942           size_t elemsize;
6943           asection *s;
6944           bfd_boolean swap_out_p;
6945
6946           /* Read in the current dynamic entry.  */
6947           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
6948
6949           /* Assume that we're going to modify it and write it out.  */
6950           swap_out_p = TRUE;
6951
6952           switch (dyn.d_tag)
6953             {
6954             case DT_RELENT:
6955               s = mips_elf_rel_dyn_section (dynobj, FALSE);
6956               BFD_ASSERT (s != NULL);
6957               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
6958               break;
6959
6960             case DT_STRSZ:
6961               /* Rewrite DT_STRSZ.  */
6962               dyn.d_un.d_val =
6963                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6964               break;
6965
6966             case DT_PLTGOT:
6967               name = ".got";
6968               goto get_vma;
6969             case DT_MIPS_CONFLICT:
6970               name = ".conflict";
6971               goto get_vma;
6972             case DT_MIPS_LIBLIST:
6973               name = ".liblist";
6974             get_vma:
6975               s = bfd_get_section_by_name (output_bfd, name);
6976               BFD_ASSERT (s != NULL);
6977               dyn.d_un.d_ptr = s->vma;
6978               break;
6979
6980             case DT_MIPS_RLD_VERSION:
6981               dyn.d_un.d_val = 1; /* XXX */
6982               break;
6983
6984             case DT_MIPS_FLAGS:
6985               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
6986               break;
6987
6988             case DT_MIPS_CONFLICTNO:
6989               name = ".conflict";
6990               elemsize = sizeof (Elf32_Conflict);
6991               goto set_elemno;
6992
6993             case DT_MIPS_LIBLISTNO:
6994               name = ".liblist";
6995               elemsize = sizeof (Elf32_Lib);
6996             set_elemno:
6997               s = bfd_get_section_by_name (output_bfd, name);
6998               if (s != NULL)
6999                 {
7000                   if (s->_cooked_size != 0)
7001                     dyn.d_un.d_val = s->_cooked_size / elemsize;
7002                   else
7003                     dyn.d_un.d_val = s->_raw_size / elemsize;
7004                 }
7005               else
7006                 dyn.d_un.d_val = 0;
7007               break;
7008
7009             case DT_MIPS_TIME_STAMP:
7010               time ((time_t *) &dyn.d_un.d_val);
7011               break;
7012
7013             case DT_MIPS_ICHECKSUM:
7014               /* XXX FIXME: */
7015               swap_out_p = FALSE;
7016               break;
7017
7018             case DT_MIPS_IVERSION:
7019               /* XXX FIXME: */
7020               swap_out_p = FALSE;
7021               break;
7022
7023             case DT_MIPS_BASE_ADDRESS:
7024               s = output_bfd->sections;
7025               BFD_ASSERT (s != NULL);
7026               dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
7027               break;
7028
7029             case DT_MIPS_LOCAL_GOTNO:
7030               dyn.d_un.d_val = g->local_gotno;
7031               break;
7032
7033             case DT_MIPS_UNREFEXTNO:
7034               /* The index into the dynamic symbol table which is the
7035                  entry of the first external symbol that is not
7036                  referenced within the same object.  */
7037               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
7038               break;
7039
7040             case DT_MIPS_GOTSYM:
7041               if (gg->global_gotsym)
7042                 {
7043                   dyn.d_un.d_val = gg->global_gotsym->dynindx;
7044                   break;
7045                 }
7046               /* In case if we don't have global got symbols we default
7047                  to setting DT_MIPS_GOTSYM to the same value as
7048                  DT_MIPS_SYMTABNO, so we just fall through.  */
7049
7050             case DT_MIPS_SYMTABNO:
7051               name = ".dynsym";
7052               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
7053               s = bfd_get_section_by_name (output_bfd, name);
7054               BFD_ASSERT (s != NULL);
7055
7056               if (s->_cooked_size != 0)
7057                 dyn.d_un.d_val = s->_cooked_size / elemsize;
7058               else
7059                 dyn.d_un.d_val = s->_raw_size / elemsize;
7060               break;
7061
7062             case DT_MIPS_HIPAGENO:
7063               dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
7064               break;
7065
7066             case DT_MIPS_RLD_MAP:
7067               dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
7068               break;
7069
7070             case DT_MIPS_OPTIONS:
7071               s = (bfd_get_section_by_name
7072                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
7073               dyn.d_un.d_ptr = s->vma;
7074               break;
7075
7076             case DT_MIPS_MSYM:
7077               s = (bfd_get_section_by_name (output_bfd, ".msym"));
7078               dyn.d_un.d_ptr = s->vma;
7079               break;
7080
7081             default:
7082               swap_out_p = FALSE;
7083               break;
7084             }
7085
7086           if (swap_out_p)
7087             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
7088               (dynobj, &dyn, b);
7089         }
7090     }
7091
7092   /* The first entry of the global offset table will be filled at
7093      runtime. The second entry will be used by some runtime loaders.
7094      This isn't the case of IRIX rld.  */
7095   if (sgot != NULL && sgot->_raw_size > 0)
7096     {
7097       MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
7098       MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
7099                          sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
7100     }
7101
7102   if (sgot != NULL)
7103     elf_section_data (sgot->output_section)->this_hdr.sh_entsize
7104       = MIPS_ELF_GOT_SIZE (output_bfd);
7105
7106   /* Generate dynamic relocations for the non-primary gots.  */
7107   if (gg != NULL && gg->next)
7108     {
7109       Elf_Internal_Rela rel[3];
7110       bfd_vma addend = 0;
7111
7112       memset (rel, 0, sizeof (rel));
7113       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
7114
7115       for (g = gg->next; g->next != gg; g = g->next)
7116         {
7117           bfd_vma index = g->next->local_gotno + g->next->global_gotno;
7118
7119           MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents
7120                              + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7121           MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000, sgot->contents
7122                              + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7123
7124           if (! info->shared)
7125             continue;
7126
7127           while (index < g->assigned_gotno)
7128             {
7129               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
7130                 = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
7131               if (!(mips_elf_create_dynamic_relocation
7132                     (output_bfd, info, rel, NULL,
7133                      bfd_abs_section_ptr,
7134                      0, &addend, sgot)))
7135                 return FALSE;
7136               BFD_ASSERT (addend == 0);
7137             }
7138         }
7139     }
7140
7141   {
7142     asection *smsym;
7143     asection *s;
7144     Elf32_compact_rel cpt;
7145
7146     /* ??? The section symbols for the output sections were set up in
7147        _bfd_elf_final_link.  SGI sets the STT_NOTYPE attribute for these
7148        symbols.  Should we do so?  */
7149
7150     smsym = bfd_get_section_by_name (dynobj, ".msym");
7151     if (smsym != NULL)
7152       {
7153         Elf32_Internal_Msym msym;
7154
7155         msym.ms_hash_value = 0;
7156         msym.ms_info = ELF32_MS_INFO (0, 1);
7157
7158         for (s = output_bfd->sections; s != NULL; s = s->next)
7159           {
7160             long dynindx = elf_section_data (s)->dynindx;
7161
7162             bfd_mips_elf_swap_msym_out
7163               (output_bfd, &msym,
7164                (((Elf32_External_Msym *) smsym->contents)
7165                 + dynindx));
7166           }
7167       }
7168
7169     if (SGI_COMPAT (output_bfd))
7170       {
7171         /* Write .compact_rel section out.  */
7172         s = bfd_get_section_by_name (dynobj, ".compact_rel");
7173         if (s != NULL)
7174           {
7175             cpt.id1 = 1;
7176             cpt.num = s->reloc_count;
7177             cpt.id2 = 2;
7178             cpt.offset = (s->output_section->filepos
7179                           + sizeof (Elf32_External_compact_rel));
7180             cpt.reserved0 = 0;
7181             cpt.reserved1 = 0;
7182             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
7183                                             ((Elf32_External_compact_rel *)
7184                                              s->contents));
7185
7186             /* Clean up a dummy stub function entry in .text.  */
7187             s = bfd_get_section_by_name (dynobj,
7188                                          MIPS_ELF_STUB_SECTION_NAME (dynobj));
7189             if (s != NULL)
7190               {
7191                 file_ptr dummy_offset;
7192
7193                 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
7194                 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
7195                 memset (s->contents + dummy_offset, 0,
7196                         MIPS_FUNCTION_STUB_SIZE);
7197               }
7198           }
7199       }
7200
7201     /* We need to sort the entries of the dynamic relocation section.  */
7202
7203     s = mips_elf_rel_dyn_section (dynobj, FALSE);
7204
7205     if (s != NULL
7206         && s->_raw_size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
7207       {
7208         reldyn_sorting_bfd = output_bfd;
7209
7210         if (ABI_64_P (output_bfd))
7211           qsort ((Elf64_External_Rel *) s->contents + 1,
7212                  (size_t) s->reloc_count - 1,
7213                  sizeof (Elf64_Mips_External_Rel), sort_dynamic_relocs_64);
7214         else
7215           qsort ((Elf32_External_Rel *) s->contents + 1,
7216                  (size_t) s->reloc_count - 1,
7217                  sizeof (Elf32_External_Rel), sort_dynamic_relocs);
7218       }
7219   }
7220
7221   return TRUE;
7222 }
7223
7224
7225 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
7226
7227 static void
7228 mips_set_isa_flags (abfd)
7229      bfd *abfd;
7230 {
7231   flagword val;
7232
7233   switch (bfd_get_mach (abfd))
7234     {
7235     default:
7236     case bfd_mach_mips3000:
7237       val = E_MIPS_ARCH_1;
7238       break;
7239
7240     case bfd_mach_mips3900:
7241       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
7242       break;
7243
7244     case bfd_mach_mips6000:
7245       val = E_MIPS_ARCH_2;
7246       break;
7247
7248     case bfd_mach_mips4000:
7249     case bfd_mach_mips4300:
7250     case bfd_mach_mips4400:
7251     case bfd_mach_mips4600:
7252       val = E_MIPS_ARCH_3;
7253       break;
7254
7255     case bfd_mach_mips4010:
7256       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
7257       break;
7258
7259     case bfd_mach_mips4100:
7260       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
7261       break;
7262
7263     case bfd_mach_mips4111:
7264       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
7265       break;
7266
7267     case bfd_mach_mips4120:
7268       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
7269       break;
7270
7271     case bfd_mach_mips4650:
7272       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
7273       break;
7274
7275     case bfd_mach_mips5400:
7276       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
7277       break;
7278
7279     case bfd_mach_mips5500:
7280       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
7281       break;
7282
7283     case bfd_mach_mips5000:
7284     case bfd_mach_mips8000:
7285     case bfd_mach_mips10000:
7286     case bfd_mach_mips12000:
7287       val = E_MIPS_ARCH_4;
7288       break;
7289
7290     case bfd_mach_mips5:
7291       val = E_MIPS_ARCH_5;
7292       break;
7293
7294     case bfd_mach_mips_sb1:
7295       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
7296       break;
7297
7298     case bfd_mach_mipsisa32:
7299       val = E_MIPS_ARCH_32;
7300       break;
7301
7302     case bfd_mach_mipsisa64:
7303       val = E_MIPS_ARCH_64;
7304       break;
7305
7306     case bfd_mach_mipsisa32r2:
7307       val = E_MIPS_ARCH_32R2;
7308       break;
7309     }
7310   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
7311   elf_elfheader (abfd)->e_flags |= val;
7312
7313 }
7314
7315
7316 /* The final processing done just before writing out a MIPS ELF object
7317    file.  This gets the MIPS architecture right based on the machine
7318    number.  This is used by both the 32-bit and the 64-bit ABI.  */
7319
7320 void
7321 _bfd_mips_elf_final_write_processing (abfd, linker)
7322      bfd *abfd;
7323      bfd_boolean linker ATTRIBUTE_UNUSED;
7324 {
7325   unsigned int i;
7326   Elf_Internal_Shdr **hdrpp;
7327   const char *name;
7328   asection *sec;
7329
7330   /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7331      is nonzero.  This is for compatibility with old objects, which used
7332      a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
7333   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
7334     mips_set_isa_flags (abfd);
7335
7336   /* Set the sh_info field for .gptab sections and other appropriate
7337      info for each special section.  */
7338   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
7339        i < elf_numsections (abfd);
7340        i++, hdrpp++)
7341     {
7342       switch ((*hdrpp)->sh_type)
7343         {
7344         case SHT_MIPS_MSYM:
7345         case SHT_MIPS_LIBLIST:
7346           sec = bfd_get_section_by_name (abfd, ".dynstr");
7347           if (sec != NULL)
7348             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7349           break;
7350
7351         case SHT_MIPS_GPTAB:
7352           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7353           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7354           BFD_ASSERT (name != NULL
7355                       && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
7356           sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
7357           BFD_ASSERT (sec != NULL);
7358           (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7359           break;
7360
7361         case SHT_MIPS_CONTENT:
7362           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7363           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7364           BFD_ASSERT (name != NULL
7365                       && strncmp (name, ".MIPS.content",
7366                                   sizeof ".MIPS.content" - 1) == 0);
7367           sec = bfd_get_section_by_name (abfd,
7368                                          name + sizeof ".MIPS.content" - 1);
7369           BFD_ASSERT (sec != NULL);
7370           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7371           break;
7372
7373         case SHT_MIPS_SYMBOL_LIB:
7374           sec = bfd_get_section_by_name (abfd, ".dynsym");
7375           if (sec != NULL)
7376             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7377           sec = bfd_get_section_by_name (abfd, ".liblist");
7378           if (sec != NULL)
7379             (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7380           break;
7381
7382         case SHT_MIPS_EVENTS:
7383           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7384           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7385           BFD_ASSERT (name != NULL);
7386           if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7387             sec = bfd_get_section_by_name (abfd,
7388                                            name + sizeof ".MIPS.events" - 1);
7389           else
7390             {
7391               BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
7392                                    sizeof ".MIPS.post_rel" - 1) == 0);
7393               sec = bfd_get_section_by_name (abfd,
7394                                              (name
7395                                               + sizeof ".MIPS.post_rel" - 1));
7396             }
7397           BFD_ASSERT (sec != NULL);
7398           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7399           break;
7400
7401         }
7402     }
7403 }
7404 \f
7405 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7406    segments.  */
7407
7408 int
7409 _bfd_mips_elf_additional_program_headers (abfd)
7410      bfd *abfd;
7411 {
7412   asection *s;
7413   int ret = 0;
7414
7415   /* See if we need a PT_MIPS_REGINFO segment.  */
7416   s = bfd_get_section_by_name (abfd, ".reginfo");
7417   if (s && (s->flags & SEC_LOAD))
7418     ++ret;
7419
7420   /* See if we need a PT_MIPS_OPTIONS segment.  */
7421   if (IRIX_COMPAT (abfd) == ict_irix6
7422       && bfd_get_section_by_name (abfd,
7423                                   MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
7424     ++ret;
7425
7426   /* See if we need a PT_MIPS_RTPROC segment.  */
7427   if (IRIX_COMPAT (abfd) == ict_irix5
7428       && bfd_get_section_by_name (abfd, ".dynamic")
7429       && bfd_get_section_by_name (abfd, ".mdebug"))
7430     ++ret;
7431
7432   return ret;
7433 }
7434
7435 /* Modify the segment map for an IRIX5 executable.  */
7436
7437 bfd_boolean
7438 _bfd_mips_elf_modify_segment_map (abfd)
7439      bfd *abfd;
7440 {
7441   asection *s;
7442   struct elf_segment_map *m, **pm;
7443   bfd_size_type amt;
7444
7445   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7446      segment.  */
7447   s = bfd_get_section_by_name (abfd, ".reginfo");
7448   if (s != NULL && (s->flags & SEC_LOAD) != 0)
7449     {
7450       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7451         if (m->p_type == PT_MIPS_REGINFO)
7452           break;
7453       if (m == NULL)
7454         {
7455           amt = sizeof *m;
7456           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7457           if (m == NULL)
7458             return FALSE;
7459
7460           m->p_type = PT_MIPS_REGINFO;
7461           m->count = 1;
7462           m->sections[0] = s;
7463
7464           /* We want to put it after the PHDR and INTERP segments.  */
7465           pm = &elf_tdata (abfd)->segment_map;
7466           while (*pm != NULL
7467                  && ((*pm)->p_type == PT_PHDR
7468                      || (*pm)->p_type == PT_INTERP))
7469             pm = &(*pm)->next;
7470
7471           m->next = *pm;
7472           *pm = m;
7473         }
7474     }
7475
7476   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7477      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
7478      PT_OPTIONS segment immediately following the program header
7479      table.  */
7480   if (NEWABI_P (abfd)
7481       /* On non-IRIX6 new abi, we'll have already created a segment
7482          for this section, so don't create another.  I'm not sure this
7483          is not also the case for IRIX 6, but I can't test it right
7484          now.  */
7485       && IRIX_COMPAT (abfd) == ict_irix6)
7486     {
7487       for (s = abfd->sections; s; s = s->next)
7488         if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
7489           break;
7490
7491       if (s)
7492         {
7493           struct elf_segment_map *options_segment;
7494
7495           /* Usually, there's a program header table.  But, sometimes
7496              there's not (like when running the `ld' testsuite).  So,
7497              if there's no program header table, we just put the
7498              options segment at the end.  */
7499           for (pm = &elf_tdata (abfd)->segment_map;
7500                *pm != NULL;
7501                pm = &(*pm)->next)
7502             if ((*pm)->p_type == PT_PHDR)
7503               break;
7504
7505           amt = sizeof (struct elf_segment_map);
7506           options_segment = bfd_zalloc (abfd, amt);
7507           options_segment->next = *pm;
7508           options_segment->p_type = PT_MIPS_OPTIONS;
7509           options_segment->p_flags = PF_R;
7510           options_segment->p_flags_valid = TRUE;
7511           options_segment->count = 1;
7512           options_segment->sections[0] = s;
7513           *pm = options_segment;
7514         }
7515     }
7516   else
7517     {
7518       if (IRIX_COMPAT (abfd) == ict_irix5)
7519         {
7520           /* If there are .dynamic and .mdebug sections, we make a room
7521              for the RTPROC header.  FIXME: Rewrite without section names.  */
7522           if (bfd_get_section_by_name (abfd, ".interp") == NULL
7523               && bfd_get_section_by_name (abfd, ".dynamic") != NULL
7524               && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
7525             {
7526               for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7527                 if (m->p_type == PT_MIPS_RTPROC)
7528                   break;
7529               if (m == NULL)
7530                 {
7531                   amt = sizeof *m;
7532                   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7533                   if (m == NULL)
7534                     return FALSE;
7535
7536                   m->p_type = PT_MIPS_RTPROC;
7537
7538                   s = bfd_get_section_by_name (abfd, ".rtproc");
7539                   if (s == NULL)
7540                     {
7541                       m->count = 0;
7542                       m->p_flags = 0;
7543                       m->p_flags_valid = 1;
7544                     }
7545                   else
7546                     {
7547                       m->count = 1;
7548                       m->sections[0] = s;
7549                     }
7550
7551                   /* We want to put it after the DYNAMIC segment.  */
7552                   pm = &elf_tdata (abfd)->segment_map;
7553                   while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
7554                     pm = &(*pm)->next;
7555                   if (*pm != NULL)
7556                     pm = &(*pm)->next;
7557
7558                   m->next = *pm;
7559                   *pm = m;
7560                 }
7561             }
7562         }
7563       /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7564          .dynstr, .dynsym, and .hash sections, and everything in
7565          between.  */
7566       for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
7567            pm = &(*pm)->next)
7568         if ((*pm)->p_type == PT_DYNAMIC)
7569           break;
7570       m = *pm;
7571       if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
7572         {
7573           /* For a normal mips executable the permissions for the PT_DYNAMIC
7574              segment are read, write and execute. We do that here since
7575              the code in elf.c sets only the read permission. This matters
7576              sometimes for the dynamic linker.  */
7577           if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
7578             {
7579               m->p_flags = PF_R | PF_W | PF_X;
7580               m->p_flags_valid = 1;
7581             }
7582         }
7583       if (m != NULL
7584           && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
7585         {
7586           static const char *sec_names[] =
7587           {
7588             ".dynamic", ".dynstr", ".dynsym", ".hash"
7589           };
7590           bfd_vma low, high;
7591           unsigned int i, c;
7592           struct elf_segment_map *n;
7593
7594           low = 0xffffffff;
7595           high = 0;
7596           for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
7597             {
7598               s = bfd_get_section_by_name (abfd, sec_names[i]);
7599               if (s != NULL && (s->flags & SEC_LOAD) != 0)
7600                 {
7601                   bfd_size_type sz;
7602
7603                   if (low > s->vma)
7604                     low = s->vma;
7605                   sz = s->_cooked_size;
7606                   if (sz == 0)
7607                     sz = s->_raw_size;
7608                   if (high < s->vma + sz)
7609                     high = s->vma + sz;
7610                 }
7611             }
7612
7613           c = 0;
7614           for (s = abfd->sections; s != NULL; s = s->next)
7615             if ((s->flags & SEC_LOAD) != 0
7616                 && s->vma >= low
7617                 && ((s->vma
7618                      + (s->_cooked_size !=
7619                         0 ? s->_cooked_size : s->_raw_size)) <= high))
7620               ++c;
7621
7622           amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
7623           n = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7624           if (n == NULL)
7625             return FALSE;
7626           *n = *m;
7627           n->count = c;
7628
7629           i = 0;
7630           for (s = abfd->sections; s != NULL; s = s->next)
7631             {
7632               if ((s->flags & SEC_LOAD) != 0
7633                   && s->vma >= low
7634                   && ((s->vma
7635                        + (s->_cooked_size != 0 ?
7636                           s->_cooked_size : s->_raw_size)) <= high))
7637                 {
7638                   n->sections[i] = s;
7639                   ++i;
7640                 }
7641             }
7642
7643           *pm = n;
7644         }
7645     }
7646
7647   return TRUE;
7648 }
7649 \f
7650 /* Return the section that should be marked against GC for a given
7651    relocation.  */
7652
7653 asection *
7654 _bfd_mips_elf_gc_mark_hook (sec, info, rel, h, sym)
7655      asection *sec;
7656      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7657      Elf_Internal_Rela *rel;
7658      struct elf_link_hash_entry *h;
7659      Elf_Internal_Sym *sym;
7660 {
7661   /* ??? Do mips16 stub sections need to be handled special?  */
7662
7663   if (h != NULL)
7664     {
7665       switch (ELF_R_TYPE (sec->owner, rel->r_info))
7666         {
7667         case R_MIPS_GNU_VTINHERIT:
7668         case R_MIPS_GNU_VTENTRY:
7669           break;
7670
7671         default:
7672           switch (h->root.type)
7673             {
7674             case bfd_link_hash_defined:
7675             case bfd_link_hash_defweak:
7676               return h->root.u.def.section;
7677
7678             case bfd_link_hash_common:
7679               return h->root.u.c.p->section;
7680
7681             default:
7682               break;
7683             }
7684         }
7685     }
7686   else
7687     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7688
7689   return NULL;
7690 }
7691
7692 /* Update the got entry reference counts for the section being removed.  */
7693
7694 bfd_boolean
7695 _bfd_mips_elf_gc_sweep_hook (abfd, info, sec, relocs)
7696      bfd *abfd ATTRIBUTE_UNUSED;
7697      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7698      asection *sec ATTRIBUTE_UNUSED;
7699      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
7700 {
7701 #if 0
7702   Elf_Internal_Shdr *symtab_hdr;
7703   struct elf_link_hash_entry **sym_hashes;
7704   bfd_signed_vma *local_got_refcounts;
7705   const Elf_Internal_Rela *rel, *relend;
7706   unsigned long r_symndx;
7707   struct elf_link_hash_entry *h;
7708
7709   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7710   sym_hashes = elf_sym_hashes (abfd);
7711   local_got_refcounts = elf_local_got_refcounts (abfd);
7712
7713   relend = relocs + sec->reloc_count;
7714   for (rel = relocs; rel < relend; rel++)
7715     switch (ELF_R_TYPE (abfd, rel->r_info))
7716       {
7717       case R_MIPS_GOT16:
7718       case R_MIPS_CALL16:
7719       case R_MIPS_CALL_HI16:
7720       case R_MIPS_CALL_LO16:
7721       case R_MIPS_GOT_HI16:
7722       case R_MIPS_GOT_LO16:
7723       case R_MIPS_GOT_DISP:
7724       case R_MIPS_GOT_PAGE:
7725       case R_MIPS_GOT_OFST:
7726         /* ??? It would seem that the existing MIPS code does no sort
7727            of reference counting or whatnot on its GOT and PLT entries,
7728            so it is not possible to garbage collect them at this time.  */
7729         break;
7730
7731       default:
7732         break;
7733       }
7734 #endif
7735
7736   return TRUE;
7737 }
7738 \f
7739 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7740    hiding the old indirect symbol.  Process additional relocation
7741    information.  Also called for weakdefs, in which case we just let
7742    _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
7743
7744 void
7745 _bfd_mips_elf_copy_indirect_symbol (bed, dir, ind)
7746      struct elf_backend_data *bed;
7747      struct elf_link_hash_entry *dir, *ind;
7748 {
7749   struct mips_elf_link_hash_entry *dirmips, *indmips;
7750
7751   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
7752
7753   if (ind->root.type != bfd_link_hash_indirect)
7754     return;
7755
7756   dirmips = (struct mips_elf_link_hash_entry *) dir;
7757   indmips = (struct mips_elf_link_hash_entry *) ind;
7758   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
7759   if (indmips->readonly_reloc)
7760     dirmips->readonly_reloc = TRUE;
7761   if (dirmips->min_dyn_reloc_index == 0
7762       || (indmips->min_dyn_reloc_index != 0
7763           && indmips->min_dyn_reloc_index < dirmips->min_dyn_reloc_index))
7764     dirmips->min_dyn_reloc_index = indmips->min_dyn_reloc_index;
7765   if (indmips->no_fn_stub)
7766     dirmips->no_fn_stub = TRUE;
7767 }
7768
7769 void
7770 _bfd_mips_elf_hide_symbol (info, entry, force_local)
7771      struct bfd_link_info *info;
7772      struct elf_link_hash_entry *entry;
7773      bfd_boolean force_local;
7774 {
7775   bfd *dynobj;
7776   asection *got;
7777   struct mips_got_info *g;
7778   struct mips_elf_link_hash_entry *h;
7779
7780   h = (struct mips_elf_link_hash_entry *) entry;
7781   if (h->forced_local)
7782     return;
7783   h->forced_local = force_local;
7784
7785   dynobj = elf_hash_table (info)->dynobj;
7786   if (dynobj != NULL && force_local)
7787     {
7788       got = mips_elf_got_section (dynobj, FALSE);
7789       g = mips_elf_section_data (got)->u.got_info;
7790
7791       if (g->next)
7792         {
7793           struct mips_got_entry e;
7794           struct mips_got_info *gg = g;
7795
7796           /* Since we're turning what used to be a global symbol into a
7797              local one, bump up the number of local entries of each GOT
7798              that had an entry for it.  This will automatically decrease
7799              the number of global entries, since global_gotno is actually
7800              the upper limit of global entries.  */
7801           e.abfd = dynobj;
7802           e.symndx = -1;
7803           e.d.h = h;
7804
7805           for (g = g->next; g != gg; g = g->next)
7806             if (htab_find (g->got_entries, &e))
7807               {
7808                 BFD_ASSERT (g->global_gotno > 0);
7809                 g->local_gotno++;
7810                 g->global_gotno--;
7811               }
7812
7813           /* If this was a global symbol forced into the primary GOT, we
7814              no longer need an entry for it.  We can't release the entry
7815              at this point, but we must at least stop counting it as one
7816              of the symbols that required a forced got entry.  */
7817           if (h->root.got.offset == 2)
7818             {
7819               BFD_ASSERT (gg->assigned_gotno > 0);
7820               gg->assigned_gotno--;
7821             }
7822         }
7823       else if (g->global_gotno == 0 && g->global_gotsym == NULL)
7824         /* If we haven't got through GOT allocation yet, just bump up the
7825            number of local entries, as this symbol won't be counted as
7826            global.  */
7827         g->local_gotno++;
7828       else if (h->root.got.offset == 1)
7829         {
7830           /* If we're past non-multi-GOT allocation and this symbol had
7831              been marked for a global got entry, give it a local entry
7832              instead.  */
7833           BFD_ASSERT (g->global_gotno > 0);
7834           g->local_gotno++;
7835           g->global_gotno--;
7836         }
7837     }
7838
7839   _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
7840 }
7841 \f
7842 #define PDR_SIZE 32
7843
7844 bfd_boolean
7845 _bfd_mips_elf_discard_info (abfd, cookie, info)
7846      bfd *abfd;
7847      struct elf_reloc_cookie *cookie;
7848      struct bfd_link_info *info;
7849 {
7850   asection *o;
7851   bfd_boolean ret = FALSE;
7852   unsigned char *tdata;
7853   size_t i, skip;
7854
7855   o = bfd_get_section_by_name (abfd, ".pdr");
7856   if (! o)
7857     return FALSE;
7858   if (o->_raw_size == 0)
7859     return FALSE;
7860   if (o->_raw_size % PDR_SIZE != 0)
7861     return FALSE;
7862   if (o->output_section != NULL
7863       && bfd_is_abs_section (o->output_section))
7864     return FALSE;
7865
7866   tdata = bfd_zmalloc (o->_raw_size / PDR_SIZE);
7867   if (! tdata)
7868     return FALSE;
7869
7870   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, (PTR) NULL,
7871                                             (Elf_Internal_Rela *) NULL,
7872                                             info->keep_memory);
7873   if (!cookie->rels)
7874     {
7875       free (tdata);
7876       return FALSE;
7877     }
7878
7879   cookie->rel = cookie->rels;
7880   cookie->relend = cookie->rels + o->reloc_count;
7881
7882   for (i = 0, skip = 0; i < o->_raw_size / PDR_SIZE; i ++)
7883     {
7884       if (MNAME(abfd,_bfd_elf,reloc_symbol_deleted_p) (i * PDR_SIZE, cookie))
7885         {
7886           tdata[i] = 1;
7887           skip ++;
7888         }
7889     }
7890
7891   if (skip != 0)
7892     {
7893       mips_elf_section_data (o)->u.tdata = tdata;
7894       o->_cooked_size = o->_raw_size - skip * PDR_SIZE;
7895       ret = TRUE;
7896     }
7897   else
7898     free (tdata);
7899
7900   if (! info->keep_memory)
7901     free (cookie->rels);
7902
7903   return ret;
7904 }
7905
7906 bfd_boolean
7907 _bfd_mips_elf_ignore_discarded_relocs (sec)
7908      asection *sec;
7909 {
7910   if (strcmp (sec->name, ".pdr") == 0)
7911     return TRUE;
7912   return FALSE;
7913 }
7914
7915 bfd_boolean
7916 _bfd_mips_elf_write_section (output_bfd, sec, contents)
7917      bfd *output_bfd;
7918      asection *sec;
7919      bfd_byte *contents;
7920 {
7921   bfd_byte *to, *from, *end;
7922   int i;
7923
7924   if (strcmp (sec->name, ".pdr") != 0)
7925     return FALSE;
7926
7927   if (mips_elf_section_data (sec)->u.tdata == NULL)
7928     return FALSE;
7929
7930   to = contents;
7931   end = contents + sec->_raw_size;
7932   for (from = contents, i = 0;
7933        from < end;
7934        from += PDR_SIZE, i++)
7935     {
7936       if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
7937         continue;
7938       if (to != from)
7939         memcpy (to, from, PDR_SIZE);
7940       to += PDR_SIZE;
7941     }
7942   bfd_set_section_contents (output_bfd, sec->output_section, contents,
7943                             (file_ptr) sec->output_offset,
7944                             sec->_cooked_size);
7945   return TRUE;
7946 }
7947 \f
7948 /* MIPS ELF uses a special find_nearest_line routine in order the
7949    handle the ECOFF debugging information.  */
7950
7951 struct mips_elf_find_line
7952 {
7953   struct ecoff_debug_info d;
7954   struct ecoff_find_line i;
7955 };
7956
7957 bfd_boolean
7958 _bfd_mips_elf_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
7959                                  functionname_ptr, line_ptr)
7960      bfd *abfd;
7961      asection *section;
7962      asymbol **symbols;
7963      bfd_vma offset;
7964      const char **filename_ptr;
7965      const char **functionname_ptr;
7966      unsigned int *line_ptr;
7967 {
7968   asection *msec;
7969
7970   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7971                                      filename_ptr, functionname_ptr,
7972                                      line_ptr))
7973     return TRUE;
7974
7975   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7976                                      filename_ptr, functionname_ptr,
7977                                      line_ptr,
7978                                      (unsigned) (ABI_64_P (abfd) ? 8 : 0),
7979                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7980     return TRUE;
7981
7982   msec = bfd_get_section_by_name (abfd, ".mdebug");
7983   if (msec != NULL)
7984     {
7985       flagword origflags;
7986       struct mips_elf_find_line *fi;
7987       const struct ecoff_debug_swap * const swap =
7988         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
7989
7990       /* If we are called during a link, mips_elf_final_link may have
7991          cleared the SEC_HAS_CONTENTS field.  We force it back on here
7992          if appropriate (which it normally will be).  */
7993       origflags = msec->flags;
7994       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
7995         msec->flags |= SEC_HAS_CONTENTS;
7996
7997       fi = elf_tdata (abfd)->find_line_info;
7998       if (fi == NULL)
7999         {
8000           bfd_size_type external_fdr_size;
8001           char *fraw_src;
8002           char *fraw_end;
8003           struct fdr *fdr_ptr;
8004           bfd_size_type amt = sizeof (struct mips_elf_find_line);
8005
8006           fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
8007           if (fi == NULL)
8008             {
8009               msec->flags = origflags;
8010               return FALSE;
8011             }
8012
8013           if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
8014             {
8015               msec->flags = origflags;
8016               return FALSE;
8017             }
8018
8019           /* Swap in the FDR information.  */
8020           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
8021           fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
8022           if (fi->d.fdr == NULL)
8023             {
8024               msec->flags = origflags;
8025               return FALSE;
8026             }
8027           external_fdr_size = swap->external_fdr_size;
8028           fdr_ptr = fi->d.fdr;
8029           fraw_src = (char *) fi->d.external_fdr;
8030           fraw_end = (fraw_src
8031                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
8032           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
8033             (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
8034
8035           elf_tdata (abfd)->find_line_info = fi;
8036
8037           /* Note that we don't bother to ever free this information.
8038              find_nearest_line is either called all the time, as in
8039              objdump -l, so the information should be saved, or it is
8040              rarely called, as in ld error messages, so the memory
8041              wasted is unimportant.  Still, it would probably be a
8042              good idea for free_cached_info to throw it away.  */
8043         }
8044
8045       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
8046                                   &fi->i, filename_ptr, functionname_ptr,
8047                                   line_ptr))
8048         {
8049           msec->flags = origflags;
8050           return TRUE;
8051         }
8052
8053       msec->flags = origflags;
8054     }
8055
8056   /* Fall back on the generic ELF find_nearest_line routine.  */
8057
8058   return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
8059                                      filename_ptr, functionname_ptr,
8060                                      line_ptr);
8061 }
8062 \f
8063 /* When are writing out the .options or .MIPS.options section,
8064    remember the bytes we are writing out, so that we can install the
8065    GP value in the section_processing routine.  */
8066
8067 bfd_boolean
8068 _bfd_mips_elf_set_section_contents (abfd, section, location, offset, count)
8069      bfd *abfd;
8070      sec_ptr section;
8071      PTR location;
8072      file_ptr offset;
8073      bfd_size_type count;
8074 {
8075   if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8076     {
8077       bfd_byte *c;
8078
8079       if (elf_section_data (section) == NULL)
8080         {
8081           bfd_size_type amt = sizeof (struct bfd_elf_section_data);
8082           section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
8083           if (elf_section_data (section) == NULL)
8084             return FALSE;
8085         }
8086       c = mips_elf_section_data (section)->u.tdata;
8087       if (c == NULL)
8088         {
8089           bfd_size_type size;
8090
8091           if (section->_cooked_size != 0)
8092             size = section->_cooked_size;
8093           else
8094             size = section->_raw_size;
8095           c = (bfd_byte *) bfd_zalloc (abfd, size);
8096           if (c == NULL)
8097             return FALSE;
8098           mips_elf_section_data (section)->u.tdata = c;
8099         }
8100
8101       memcpy (c + offset, location, (size_t) count);
8102     }
8103
8104   return _bfd_elf_set_section_contents (abfd, section, location, offset,
8105                                         count);
8106 }
8107
8108 /* This is almost identical to bfd_generic_get_... except that some
8109    MIPS relocations need to be handled specially.  Sigh.  */
8110
8111 bfd_byte *
8112 _bfd_elf_mips_get_relocated_section_contents (abfd, link_info, link_order,
8113                                               data, relocatable, symbols)
8114      bfd *abfd;
8115      struct bfd_link_info *link_info;
8116      struct bfd_link_order *link_order;
8117      bfd_byte *data;
8118      bfd_boolean relocatable;
8119      asymbol **symbols;
8120 {
8121   /* Get enough memory to hold the stuff */
8122   bfd *input_bfd = link_order->u.indirect.section->owner;
8123   asection *input_section = link_order->u.indirect.section;
8124
8125   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
8126   arelent **reloc_vector = NULL;
8127   long reloc_count;
8128
8129   if (reloc_size < 0)
8130     goto error_return;
8131
8132   reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
8133   if (reloc_vector == NULL && reloc_size != 0)
8134     goto error_return;
8135
8136   /* read in the section */
8137   if (!bfd_get_section_contents (input_bfd,
8138                                  input_section,
8139                                  (PTR) data,
8140                                  (file_ptr) 0,
8141                                  input_section->_raw_size))
8142     goto error_return;
8143
8144   /* We're not relaxing the section, so just copy the size info */
8145   input_section->_cooked_size = input_section->_raw_size;
8146   input_section->reloc_done = TRUE;
8147
8148   reloc_count = bfd_canonicalize_reloc (input_bfd,
8149                                         input_section,
8150                                         reloc_vector,
8151                                         symbols);
8152   if (reloc_count < 0)
8153     goto error_return;
8154
8155   if (reloc_count > 0)
8156     {
8157       arelent **parent;
8158       /* for mips */
8159       int gp_found;
8160       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
8161
8162       {
8163         struct bfd_hash_entry *h;
8164         struct bfd_link_hash_entry *lh;
8165         /* Skip all this stuff if we aren't mixing formats.  */
8166         if (abfd && input_bfd
8167             && abfd->xvec == input_bfd->xvec)
8168           lh = 0;
8169         else
8170           {
8171             h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
8172             lh = (struct bfd_link_hash_entry *) h;
8173           }
8174       lookup:
8175         if (lh)
8176           {
8177             switch (lh->type)
8178               {
8179               case bfd_link_hash_undefined:
8180               case bfd_link_hash_undefweak:
8181               case bfd_link_hash_common:
8182                 gp_found = 0;
8183                 break;
8184               case bfd_link_hash_defined:
8185               case bfd_link_hash_defweak:
8186                 gp_found = 1;
8187                 gp = lh->u.def.value;
8188                 break;
8189               case bfd_link_hash_indirect:
8190               case bfd_link_hash_warning:
8191                 lh = lh->u.i.link;
8192                 /* @@FIXME  ignoring warning for now */
8193                 goto lookup;
8194               case bfd_link_hash_new:
8195               default:
8196                 abort ();
8197               }
8198           }
8199         else
8200           gp_found = 0;
8201       }
8202       /* end mips */
8203       for (parent = reloc_vector; *parent != (arelent *) NULL;
8204            parent++)
8205         {
8206           char *error_message = (char *) NULL;
8207           bfd_reloc_status_type r;
8208
8209           /* Specific to MIPS: Deal with relocation types that require
8210              knowing the gp of the output bfd.  */
8211           asymbol *sym = *(*parent)->sym_ptr_ptr;
8212           if (bfd_is_abs_section (sym->section) && abfd)
8213             {
8214               /* The special_function wouldn't get called anyway.  */
8215             }
8216           else if (!gp_found)
8217             {
8218               /* The gp isn't there; let the special function code
8219                  fall over on its own.  */
8220             }
8221           else if ((*parent)->howto->special_function
8222                    == _bfd_mips_elf32_gprel16_reloc)
8223             {
8224               /* bypass special_function call */
8225               r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
8226                                                  input_section, relocatable,
8227                                                  (PTR) data, gp);
8228               goto skip_bfd_perform_relocation;
8229             }
8230           /* end mips specific stuff */
8231
8232           r = bfd_perform_relocation (input_bfd,
8233                                       *parent,
8234                                       (PTR) data,
8235                                       input_section,
8236                                       relocatable ? abfd : (bfd *) NULL,
8237                                       &error_message);
8238         skip_bfd_perform_relocation:
8239
8240           if (relocatable)
8241             {
8242               asection *os = input_section->output_section;
8243
8244               /* A partial link, so keep the relocs */
8245               os->orelocation[os->reloc_count] = *parent;
8246               os->reloc_count++;
8247             }
8248
8249           if (r != bfd_reloc_ok)
8250             {
8251               switch (r)
8252                 {
8253                 case bfd_reloc_undefined:
8254                   if (!((*link_info->callbacks->undefined_symbol)
8255                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8256                          input_bfd, input_section, (*parent)->address,
8257                          TRUE)))
8258                     goto error_return;
8259                   break;
8260                 case bfd_reloc_dangerous:
8261                   BFD_ASSERT (error_message != (char *) NULL);
8262                   if (!((*link_info->callbacks->reloc_dangerous)
8263                         (link_info, error_message, input_bfd, input_section,
8264                          (*parent)->address)))
8265                     goto error_return;
8266                   break;
8267                 case bfd_reloc_overflow:
8268                   if (!((*link_info->callbacks->reloc_overflow)
8269                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8270                          (*parent)->howto->name, (*parent)->addend,
8271                          input_bfd, input_section, (*parent)->address)))
8272                     goto error_return;
8273                   break;
8274                 case bfd_reloc_outofrange:
8275                 default:
8276                   abort ();
8277                   break;
8278                 }
8279
8280             }
8281         }
8282     }
8283   if (reloc_vector != NULL)
8284     free (reloc_vector);
8285   return data;
8286
8287 error_return:
8288   if (reloc_vector != NULL)
8289     free (reloc_vector);
8290   return NULL;
8291 }
8292 \f
8293 /* Create a MIPS ELF linker hash table.  */
8294
8295 struct bfd_link_hash_table *
8296 _bfd_mips_elf_link_hash_table_create (abfd)
8297      bfd *abfd;
8298 {
8299   struct mips_elf_link_hash_table *ret;
8300   bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
8301
8302   ret = (struct mips_elf_link_hash_table *) bfd_malloc (amt);
8303   if (ret == (struct mips_elf_link_hash_table *) NULL)
8304     return NULL;
8305
8306   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
8307                                        mips_elf_link_hash_newfunc))
8308     {
8309       free (ret);
8310       return NULL;
8311     }
8312
8313 #if 0
8314   /* We no longer use this.  */
8315   for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
8316     ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
8317 #endif
8318   ret->procedure_count = 0;
8319   ret->compact_rel_size = 0;
8320   ret->use_rld_obj_head = FALSE;
8321   ret->rld_value = 0;
8322   ret->mips16_stubs_seen = FALSE;
8323
8324   return &ret->root.root;
8325 }
8326 \f
8327 /* We need to use a special link routine to handle the .reginfo and
8328    the .mdebug sections.  We need to merge all instances of these
8329    sections together, not write them all out sequentially.  */
8330
8331 bfd_boolean
8332 _bfd_mips_elf_final_link (abfd, info)
8333      bfd *abfd;
8334      struct bfd_link_info *info;
8335 {
8336   asection **secpp;
8337   asection *o;
8338   struct bfd_link_order *p;
8339   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
8340   asection *rtproc_sec;
8341   Elf32_RegInfo reginfo;
8342   struct ecoff_debug_info debug;
8343   const struct ecoff_debug_swap *swap
8344     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
8345   HDRR *symhdr = &debug.symbolic_header;
8346   PTR mdebug_handle = NULL;
8347   asection *s;
8348   EXTR esym;
8349   unsigned int i;
8350   bfd_size_type amt;
8351
8352   static const char * const secname[] =
8353   {
8354     ".text", ".init", ".fini", ".data",
8355     ".rodata", ".sdata", ".sbss", ".bss"
8356   };
8357   static const int sc[] =
8358   {
8359     scText, scInit, scFini, scData,
8360     scRData, scSData, scSBss, scBss
8361   };
8362
8363   /* We'd carefully arranged the dynamic symbol indices, and then the
8364      generic size_dynamic_sections renumbered them out from under us.
8365      Rather than trying somehow to prevent the renumbering, just do
8366      the sort again.  */
8367   if (elf_hash_table (info)->dynamic_sections_created)
8368     {
8369       bfd *dynobj;
8370       asection *got;
8371       struct mips_got_info *g;
8372
8373       /* When we resort, we must tell mips_elf_sort_hash_table what
8374          the lowest index it may use is.  That's the number of section
8375          symbols we're going to add.  The generic ELF linker only
8376          adds these symbols when building a shared object.  Note that
8377          we count the sections after (possibly) removing the .options
8378          section above.  */
8379       if (! mips_elf_sort_hash_table (info, (info->shared
8380                                              ? bfd_count_sections (abfd) + 1
8381                                              : 1)))
8382         return FALSE;
8383
8384       /* Make sure we didn't grow the global .got region.  */
8385       dynobj = elf_hash_table (info)->dynobj;
8386       got = mips_elf_got_section (dynobj, FALSE);
8387       g = mips_elf_section_data (got)->u.got_info;
8388
8389       if (g->global_gotsym != NULL)
8390         BFD_ASSERT ((elf_hash_table (info)->dynsymcount
8391                      - g->global_gotsym->dynindx)
8392                     <= g->global_gotno);
8393     }
8394
8395 #if 0
8396   /* We want to set the GP value for ld -r.  */
8397   /* On IRIX5, we omit the .options section.  On IRIX6, however, we
8398      include it, even though we don't process it quite right.  (Some
8399      entries are supposed to be merged.)  Empirically, we seem to be
8400      better off including it then not.  */
8401   if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
8402     for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8403       {
8404         if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8405           {
8406             for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8407               if (p->type == bfd_indirect_link_order)
8408                 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
8409             (*secpp)->link_order_head = NULL;
8410             bfd_section_list_remove (abfd, secpp);
8411             --abfd->section_count;
8412
8413             break;
8414           }
8415       }
8416
8417   /* We include .MIPS.options, even though we don't process it quite right.
8418      (Some entries are supposed to be merged.)  At IRIX6 empirically we seem
8419      to be better off including it than not.  */
8420   for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8421     {
8422       if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
8423         {
8424           for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8425             if (p->type == bfd_indirect_link_order)
8426               p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
8427           (*secpp)->link_order_head = NULL;
8428           bfd_section_list_remove (abfd, secpp);
8429           --abfd->section_count;
8430
8431           break;
8432         }
8433     }
8434 #endif
8435
8436   /* Get a value for the GP register.  */
8437   if (elf_gp (abfd) == 0)
8438     {
8439       struct bfd_link_hash_entry *h;
8440
8441       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
8442       if (h != (struct bfd_link_hash_entry *) NULL
8443           && h->type == bfd_link_hash_defined)
8444         elf_gp (abfd) = (h->u.def.value
8445                          + h->u.def.section->output_section->vma
8446                          + h->u.def.section->output_offset);
8447       else if (info->relocatable)
8448         {
8449           bfd_vma lo = MINUS_ONE;
8450
8451           /* Find the GP-relative section with the lowest offset.  */
8452           for (o = abfd->sections; o != (asection *) NULL; o = o->next)
8453             if (o->vma < lo
8454                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
8455               lo = o->vma;
8456
8457           /* And calculate GP relative to that.  */
8458           elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
8459         }
8460       else
8461         {
8462           /* If the relocate_section function needs to do a reloc
8463              involving the GP value, it should make a reloc_dangerous
8464              callback to warn that GP is not defined.  */
8465         }
8466     }
8467
8468   /* Go through the sections and collect the .reginfo and .mdebug
8469      information.  */
8470   reginfo_sec = NULL;
8471   mdebug_sec = NULL;
8472   gptab_data_sec = NULL;
8473   gptab_bss_sec = NULL;
8474   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
8475     {
8476       if (strcmp (o->name, ".reginfo") == 0)
8477         {
8478           memset (&reginfo, 0, sizeof reginfo);
8479
8480           /* We have found the .reginfo section in the output file.
8481              Look through all the link_orders comprising it and merge
8482              the information together.  */
8483           for (p = o->link_order_head;
8484                p != (struct bfd_link_order *) NULL;
8485                p = p->next)
8486             {
8487               asection *input_section;
8488               bfd *input_bfd;
8489               Elf32_External_RegInfo ext;
8490               Elf32_RegInfo sub;
8491
8492               if (p->type != bfd_indirect_link_order)
8493                 {
8494                   if (p->type == bfd_data_link_order)
8495                     continue;
8496                   abort ();
8497                 }
8498
8499               input_section = p->u.indirect.section;
8500               input_bfd = input_section->owner;
8501
8502               /* The linker emulation code has probably clobbered the
8503                  size to be zero bytes.  */
8504               if (input_section->_raw_size == 0)
8505                 input_section->_raw_size = sizeof (Elf32_External_RegInfo);
8506
8507               if (! bfd_get_section_contents (input_bfd, input_section,
8508                                               (PTR) &ext,
8509                                               (file_ptr) 0,
8510                                               (bfd_size_type) sizeof ext))
8511                 return FALSE;
8512
8513               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
8514
8515               reginfo.ri_gprmask |= sub.ri_gprmask;
8516               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
8517               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
8518               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
8519               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
8520
8521               /* ri_gp_value is set by the function
8522                  mips_elf32_section_processing when the section is
8523                  finally written out.  */
8524
8525               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8526                  elf_link_input_bfd ignores this section.  */
8527               input_section->flags &= ~SEC_HAS_CONTENTS;
8528             }
8529
8530           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
8531           BFD_ASSERT(o->_raw_size == sizeof (Elf32_External_RegInfo));
8532
8533           /* Skip this section later on (I don't think this currently
8534              matters, but someday it might).  */
8535           o->link_order_head = (struct bfd_link_order *) NULL;
8536
8537           reginfo_sec = o;
8538         }
8539
8540       if (strcmp (o->name, ".mdebug") == 0)
8541         {
8542           struct extsym_info einfo;
8543           bfd_vma last;
8544
8545           /* We have found the .mdebug section in the output file.
8546              Look through all the link_orders comprising it and merge
8547              the information together.  */
8548           symhdr->magic = swap->sym_magic;
8549           /* FIXME: What should the version stamp be?  */
8550           symhdr->vstamp = 0;
8551           symhdr->ilineMax = 0;
8552           symhdr->cbLine = 0;
8553           symhdr->idnMax = 0;
8554           symhdr->ipdMax = 0;
8555           symhdr->isymMax = 0;
8556           symhdr->ioptMax = 0;
8557           symhdr->iauxMax = 0;
8558           symhdr->issMax = 0;
8559           symhdr->issExtMax = 0;
8560           symhdr->ifdMax = 0;
8561           symhdr->crfd = 0;
8562           symhdr->iextMax = 0;
8563
8564           /* We accumulate the debugging information itself in the
8565              debug_info structure.  */
8566           debug.line = NULL;
8567           debug.external_dnr = NULL;
8568           debug.external_pdr = NULL;
8569           debug.external_sym = NULL;
8570           debug.external_opt = NULL;
8571           debug.external_aux = NULL;
8572           debug.ss = NULL;
8573           debug.ssext = debug.ssext_end = NULL;
8574           debug.external_fdr = NULL;
8575           debug.external_rfd = NULL;
8576           debug.external_ext = debug.external_ext_end = NULL;
8577
8578           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
8579           if (mdebug_handle == (PTR) NULL)
8580             return FALSE;
8581
8582           esym.jmptbl = 0;
8583           esym.cobol_main = 0;
8584           esym.weakext = 0;
8585           esym.reserved = 0;
8586           esym.ifd = ifdNil;
8587           esym.asym.iss = issNil;
8588           esym.asym.st = stLocal;
8589           esym.asym.reserved = 0;
8590           esym.asym.index = indexNil;
8591           last = 0;
8592           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
8593             {
8594               esym.asym.sc = sc[i];
8595               s = bfd_get_section_by_name (abfd, secname[i]);
8596               if (s != NULL)
8597                 {
8598                   esym.asym.value = s->vma;
8599                   last = s->vma + s->_raw_size;
8600                 }
8601               else
8602                 esym.asym.value = last;
8603               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
8604                                                  secname[i], &esym))
8605                 return FALSE;
8606             }
8607
8608           for (p = o->link_order_head;
8609                p != (struct bfd_link_order *) NULL;
8610                p = p->next)
8611             {
8612               asection *input_section;
8613               bfd *input_bfd;
8614               const struct ecoff_debug_swap *input_swap;
8615               struct ecoff_debug_info input_debug;
8616               char *eraw_src;
8617               char *eraw_end;
8618
8619               if (p->type != bfd_indirect_link_order)
8620                 {
8621                   if (p->type == bfd_data_link_order)
8622                     continue;
8623                   abort ();
8624                 }
8625
8626               input_section = p->u.indirect.section;
8627               input_bfd = input_section->owner;
8628
8629               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
8630                   || (get_elf_backend_data (input_bfd)
8631                       ->elf_backend_ecoff_debug_swap) == NULL)
8632                 {
8633                   /* I don't know what a non MIPS ELF bfd would be
8634                      doing with a .mdebug section, but I don't really
8635                      want to deal with it.  */
8636                   continue;
8637                 }
8638
8639               input_swap = (get_elf_backend_data (input_bfd)
8640                             ->elf_backend_ecoff_debug_swap);
8641
8642               BFD_ASSERT (p->size == input_section->_raw_size);
8643
8644               /* The ECOFF linking code expects that we have already
8645                  read in the debugging information and set up an
8646                  ecoff_debug_info structure, so we do that now.  */
8647               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
8648                                                    &input_debug))
8649                 return FALSE;
8650
8651               if (! (bfd_ecoff_debug_accumulate
8652                      (mdebug_handle, abfd, &debug, swap, input_bfd,
8653                       &input_debug, input_swap, info)))
8654                 return FALSE;
8655
8656               /* Loop through the external symbols.  For each one with
8657                  interesting information, try to find the symbol in
8658                  the linker global hash table and save the information
8659                  for the output external symbols.  */
8660               eraw_src = input_debug.external_ext;
8661               eraw_end = (eraw_src
8662                           + (input_debug.symbolic_header.iextMax
8663                              * input_swap->external_ext_size));
8664               for (;
8665                    eraw_src < eraw_end;
8666                    eraw_src += input_swap->external_ext_size)
8667                 {
8668                   EXTR ext;
8669                   const char *name;
8670                   struct mips_elf_link_hash_entry *h;
8671
8672                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
8673                   if (ext.asym.sc == scNil
8674                       || ext.asym.sc == scUndefined
8675                       || ext.asym.sc == scSUndefined)
8676                     continue;
8677
8678                   name = input_debug.ssext + ext.asym.iss;
8679                   h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
8680                                                  name, FALSE, FALSE, TRUE);
8681                   if (h == NULL || h->esym.ifd != -2)
8682                     continue;
8683
8684                   if (ext.ifd != -1)
8685                     {
8686                       BFD_ASSERT (ext.ifd
8687                                   < input_debug.symbolic_header.ifdMax);
8688                       ext.ifd = input_debug.ifdmap[ext.ifd];
8689                     }
8690
8691                   h->esym = ext;
8692                 }
8693
8694               /* Free up the information we just read.  */
8695               free (input_debug.line);
8696               free (input_debug.external_dnr);
8697               free (input_debug.external_pdr);
8698               free (input_debug.external_sym);
8699               free (input_debug.external_opt);
8700               free (input_debug.external_aux);
8701               free (input_debug.ss);
8702               free (input_debug.ssext);
8703               free (input_debug.external_fdr);
8704               free (input_debug.external_rfd);
8705               free (input_debug.external_ext);
8706
8707               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8708                  elf_link_input_bfd ignores this section.  */
8709               input_section->flags &= ~SEC_HAS_CONTENTS;
8710             }
8711
8712           if (SGI_COMPAT (abfd) && info->shared)
8713             {
8714               /* Create .rtproc section.  */
8715               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8716               if (rtproc_sec == NULL)
8717                 {
8718                   flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
8719                                     | SEC_LINKER_CREATED | SEC_READONLY);
8720
8721                   rtproc_sec = bfd_make_section (abfd, ".rtproc");
8722                   if (rtproc_sec == NULL
8723                       || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
8724                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
8725                     return FALSE;
8726                 }
8727
8728               if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
8729                                                      info, rtproc_sec,
8730                                                      &debug))
8731                 return FALSE;
8732             }
8733
8734           /* Build the external symbol information.  */
8735           einfo.abfd = abfd;
8736           einfo.info = info;
8737           einfo.debug = &debug;
8738           einfo.swap = swap;
8739           einfo.failed = FALSE;
8740           mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8741                                        mips_elf_output_extsym,
8742                                        (PTR) &einfo);
8743           if (einfo.failed)
8744             return FALSE;
8745
8746           /* Set the size of the .mdebug section.  */
8747           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
8748
8749           /* Skip this section later on (I don't think this currently
8750              matters, but someday it might).  */
8751           o->link_order_head = (struct bfd_link_order *) NULL;
8752
8753           mdebug_sec = o;
8754         }
8755
8756       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
8757         {
8758           const char *subname;
8759           unsigned int c;
8760           Elf32_gptab *tab;
8761           Elf32_External_gptab *ext_tab;
8762           unsigned int j;
8763
8764           /* The .gptab.sdata and .gptab.sbss sections hold
8765              information describing how the small data area would
8766              change depending upon the -G switch.  These sections
8767              not used in executables files.  */
8768           if (! info->relocatable)
8769             {
8770               for (p = o->link_order_head;
8771                    p != (struct bfd_link_order *) NULL;
8772                    p = p->next)
8773                 {
8774                   asection *input_section;
8775
8776                   if (p->type != bfd_indirect_link_order)
8777                     {
8778                       if (p->type == bfd_data_link_order)
8779                         continue;
8780                       abort ();
8781                     }
8782
8783                   input_section = p->u.indirect.section;
8784
8785                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
8786                      elf_link_input_bfd ignores this section.  */
8787                   input_section->flags &= ~SEC_HAS_CONTENTS;
8788                 }
8789
8790               /* Skip this section later on (I don't think this
8791                  currently matters, but someday it might).  */
8792               o->link_order_head = (struct bfd_link_order *) NULL;
8793
8794               /* Really remove the section.  */
8795               for (secpp = &abfd->sections;
8796                    *secpp != o;
8797                    secpp = &(*secpp)->next)
8798                 ;
8799               bfd_section_list_remove (abfd, secpp);
8800               --abfd->section_count;
8801
8802               continue;
8803             }
8804
8805           /* There is one gptab for initialized data, and one for
8806              uninitialized data.  */
8807           if (strcmp (o->name, ".gptab.sdata") == 0)
8808             gptab_data_sec = o;
8809           else if (strcmp (o->name, ".gptab.sbss") == 0)
8810             gptab_bss_sec = o;
8811           else
8812             {
8813               (*_bfd_error_handler)
8814                 (_("%s: illegal section name `%s'"),
8815                  bfd_get_filename (abfd), o->name);
8816               bfd_set_error (bfd_error_nonrepresentable_section);
8817               return FALSE;
8818             }
8819
8820           /* The linker script always combines .gptab.data and
8821              .gptab.sdata into .gptab.sdata, and likewise for
8822              .gptab.bss and .gptab.sbss.  It is possible that there is
8823              no .sdata or .sbss section in the output file, in which
8824              case we must change the name of the output section.  */
8825           subname = o->name + sizeof ".gptab" - 1;
8826           if (bfd_get_section_by_name (abfd, subname) == NULL)
8827             {
8828               if (o == gptab_data_sec)
8829                 o->name = ".gptab.data";
8830               else
8831                 o->name = ".gptab.bss";
8832               subname = o->name + sizeof ".gptab" - 1;
8833               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
8834             }
8835
8836           /* Set up the first entry.  */
8837           c = 1;
8838           amt = c * sizeof (Elf32_gptab);
8839           tab = (Elf32_gptab *) bfd_malloc (amt);
8840           if (tab == NULL)
8841             return FALSE;
8842           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
8843           tab[0].gt_header.gt_unused = 0;
8844
8845           /* Combine the input sections.  */
8846           for (p = o->link_order_head;
8847                p != (struct bfd_link_order *) NULL;
8848                p = p->next)
8849             {
8850               asection *input_section;
8851               bfd *input_bfd;
8852               bfd_size_type size;
8853               unsigned long last;
8854               bfd_size_type gpentry;
8855
8856               if (p->type != bfd_indirect_link_order)
8857                 {
8858                   if (p->type == bfd_data_link_order)
8859                     continue;
8860                   abort ();
8861                 }
8862
8863               input_section = p->u.indirect.section;
8864               input_bfd = input_section->owner;
8865
8866               /* Combine the gptab entries for this input section one
8867                  by one.  We know that the input gptab entries are
8868                  sorted by ascending -G value.  */
8869               size = bfd_section_size (input_bfd, input_section);
8870               last = 0;
8871               for (gpentry = sizeof (Elf32_External_gptab);
8872                    gpentry < size;
8873                    gpentry += sizeof (Elf32_External_gptab))
8874                 {
8875                   Elf32_External_gptab ext_gptab;
8876                   Elf32_gptab int_gptab;
8877                   unsigned long val;
8878                   unsigned long add;
8879                   bfd_boolean exact;
8880                   unsigned int look;
8881
8882                   if (! (bfd_get_section_contents
8883                          (input_bfd, input_section, (PTR) &ext_gptab,
8884                           (file_ptr) gpentry,
8885                           (bfd_size_type) sizeof (Elf32_External_gptab))))
8886                     {
8887                       free (tab);
8888                       return FALSE;
8889                     }
8890
8891                   bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
8892                                                 &int_gptab);
8893                   val = int_gptab.gt_entry.gt_g_value;
8894                   add = int_gptab.gt_entry.gt_bytes - last;
8895
8896                   exact = FALSE;
8897                   for (look = 1; look < c; look++)
8898                     {
8899                       if (tab[look].gt_entry.gt_g_value >= val)
8900                         tab[look].gt_entry.gt_bytes += add;
8901
8902                       if (tab[look].gt_entry.gt_g_value == val)
8903                         exact = TRUE;
8904                     }
8905
8906                   if (! exact)
8907                     {
8908                       Elf32_gptab *new_tab;
8909                       unsigned int max;
8910
8911                       /* We need a new table entry.  */
8912                       amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
8913                       new_tab = (Elf32_gptab *) bfd_realloc ((PTR) tab, amt);
8914                       if (new_tab == NULL)
8915                         {
8916                           free (tab);
8917                           return FALSE;
8918                         }
8919                       tab = new_tab;
8920                       tab[c].gt_entry.gt_g_value = val;
8921                       tab[c].gt_entry.gt_bytes = add;
8922
8923                       /* Merge in the size for the next smallest -G
8924                          value, since that will be implied by this new
8925                          value.  */
8926                       max = 0;
8927                       for (look = 1; look < c; look++)
8928                         {
8929                           if (tab[look].gt_entry.gt_g_value < val
8930                               && (max == 0
8931                                   || (tab[look].gt_entry.gt_g_value
8932                                       > tab[max].gt_entry.gt_g_value)))
8933                             max = look;
8934                         }
8935                       if (max != 0)
8936                         tab[c].gt_entry.gt_bytes +=
8937                           tab[max].gt_entry.gt_bytes;
8938
8939                       ++c;
8940                     }
8941
8942                   last = int_gptab.gt_entry.gt_bytes;
8943                 }
8944
8945               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8946                  elf_link_input_bfd ignores this section.  */
8947               input_section->flags &= ~SEC_HAS_CONTENTS;
8948             }
8949
8950           /* The table must be sorted by -G value.  */
8951           if (c > 2)
8952             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
8953
8954           /* Swap out the table.  */
8955           amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
8956           ext_tab = (Elf32_External_gptab *) bfd_alloc (abfd, amt);
8957           if (ext_tab == NULL)
8958             {
8959               free (tab);
8960               return FALSE;
8961             }
8962
8963           for (j = 0; j < c; j++)
8964             bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
8965           free (tab);
8966
8967           o->_raw_size = c * sizeof (Elf32_External_gptab);
8968           o->contents = (bfd_byte *) ext_tab;
8969
8970           /* Skip this section later on (I don't think this currently
8971              matters, but someday it might).  */
8972           o->link_order_head = (struct bfd_link_order *) NULL;
8973         }
8974     }
8975
8976   /* Invoke the regular ELF backend linker to do all the work.  */
8977   if (!MNAME(abfd,bfd_elf,bfd_final_link) (abfd, info))
8978     return FALSE;
8979
8980   /* Now write out the computed sections.  */
8981
8982   if (reginfo_sec != (asection *) NULL)
8983     {
8984       Elf32_External_RegInfo ext;
8985
8986       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
8987       if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
8988                                       (file_ptr) 0,
8989                                       (bfd_size_type) sizeof ext))
8990         return FALSE;
8991     }
8992
8993   if (mdebug_sec != (asection *) NULL)
8994     {
8995       BFD_ASSERT (abfd->output_has_begun);
8996       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
8997                                                swap, info,
8998                                                mdebug_sec->filepos))
8999         return FALSE;
9000
9001       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
9002     }
9003
9004   if (gptab_data_sec != (asection *) NULL)
9005     {
9006       if (! bfd_set_section_contents (abfd, gptab_data_sec,
9007                                       gptab_data_sec->contents,
9008                                       (file_ptr) 0,
9009                                       gptab_data_sec->_raw_size))
9010         return FALSE;
9011     }
9012
9013   if (gptab_bss_sec != (asection *) NULL)
9014     {
9015       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
9016                                       gptab_bss_sec->contents,
9017                                       (file_ptr) 0,
9018                                       gptab_bss_sec->_raw_size))
9019         return FALSE;
9020     }
9021
9022   if (SGI_COMPAT (abfd))
9023     {
9024       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
9025       if (rtproc_sec != NULL)
9026         {
9027           if (! bfd_set_section_contents (abfd, rtproc_sec,
9028                                           rtproc_sec->contents,
9029                                           (file_ptr) 0,
9030                                           rtproc_sec->_raw_size))
9031             return FALSE;
9032         }
9033     }
9034
9035   return TRUE;
9036 }
9037 \f
9038 /* Structure for saying that BFD machine EXTENSION extends BASE.  */
9039
9040 struct mips_mach_extension {
9041   unsigned long extension, base;
9042 };
9043
9044
9045 /* An array describing how BFD machines relate to one another.  The entries
9046    are ordered topologically with MIPS I extensions listed last.  */
9047
9048 static const struct mips_mach_extension mips_mach_extensions[] = {
9049   /* MIPS64 extensions.  */
9050   { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
9051
9052   /* MIPS V extensions.  */
9053   { bfd_mach_mipsisa64, bfd_mach_mips5 },
9054
9055   /* R10000 extensions.  */
9056   { bfd_mach_mips12000, bfd_mach_mips10000 },
9057
9058   /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
9059      vr5400 ISA, but doesn't include the multimedia stuff.  It seems
9060      better to allow vr5400 and vr5500 code to be merged anyway, since
9061      many libraries will just use the core ISA.  Perhaps we could add
9062      some sort of ASE flag if this ever proves a problem.  */
9063   { bfd_mach_mips5500, bfd_mach_mips5400 },
9064   { bfd_mach_mips5400, bfd_mach_mips5000 },
9065
9066   /* MIPS IV extensions.  */
9067   { bfd_mach_mips5, bfd_mach_mips8000 },
9068   { bfd_mach_mips10000, bfd_mach_mips8000 },
9069   { bfd_mach_mips5000, bfd_mach_mips8000 },
9070
9071   /* VR4100 extensions.  */
9072   { bfd_mach_mips4120, bfd_mach_mips4100 },
9073   { bfd_mach_mips4111, bfd_mach_mips4100 },
9074
9075   /* MIPS III extensions.  */
9076   { bfd_mach_mips8000, bfd_mach_mips4000 },
9077   { bfd_mach_mips4650, bfd_mach_mips4000 },
9078   { bfd_mach_mips4600, bfd_mach_mips4000 },
9079   { bfd_mach_mips4400, bfd_mach_mips4000 },
9080   { bfd_mach_mips4300, bfd_mach_mips4000 },
9081   { bfd_mach_mips4100, bfd_mach_mips4000 },
9082   { bfd_mach_mips4010, bfd_mach_mips4000 },
9083
9084   /* MIPS32 extensions.  */
9085   { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
9086
9087   /* MIPS II extensions.  */
9088   { bfd_mach_mips4000, bfd_mach_mips6000 },
9089   { bfd_mach_mipsisa32, bfd_mach_mips6000 },
9090
9091   /* MIPS I extensions.  */
9092   { bfd_mach_mips6000, bfd_mach_mips3000 },
9093   { bfd_mach_mips3900, bfd_mach_mips3000 }
9094 };
9095
9096
9097 /* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
9098
9099 static bfd_boolean
9100 mips_mach_extends_p (base, extension)
9101      unsigned long base, extension;
9102 {
9103   size_t i;
9104
9105   for (i = 0; extension != base && i < ARRAY_SIZE (mips_mach_extensions); i++)
9106     if (extension == mips_mach_extensions[i].extension)
9107       extension = mips_mach_extensions[i].base;
9108
9109   return extension == base;
9110 }
9111
9112
9113 /* Return true if the given ELF header flags describe a 32-bit binary.  */
9114
9115 static bfd_boolean
9116 mips_32bit_flags_p (flags)
9117      flagword flags;
9118 {
9119   return ((flags & EF_MIPS_32BITMODE) != 0
9120           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
9121           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
9122           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
9123           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
9124           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
9125           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
9126 }
9127
9128
9129 /* Merge backend specific data from an object file to the output
9130    object file when linking.  */
9131
9132 bfd_boolean
9133 _bfd_mips_elf_merge_private_bfd_data (ibfd, obfd)
9134      bfd *ibfd;
9135      bfd *obfd;
9136 {
9137   flagword old_flags;
9138   flagword new_flags;
9139   bfd_boolean ok;
9140   bfd_boolean null_input_bfd = TRUE;
9141   asection *sec;
9142
9143   /* Check if we have the same endianess */
9144   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
9145     {
9146       (*_bfd_error_handler)
9147         (_("%s: endianness incompatible with that of the selected emulation"),
9148          bfd_archive_filename (ibfd));
9149       return FALSE;
9150     }
9151
9152   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
9153       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
9154     return TRUE;
9155
9156   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
9157     {
9158       (*_bfd_error_handler)
9159         (_("%s: ABI is incompatible with that of the selected emulation"),
9160          bfd_archive_filename (ibfd));
9161       return FALSE;
9162     }
9163
9164   new_flags = elf_elfheader (ibfd)->e_flags;
9165   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
9166   old_flags = elf_elfheader (obfd)->e_flags;
9167
9168   if (! elf_flags_init (obfd))
9169     {
9170       elf_flags_init (obfd) = TRUE;
9171       elf_elfheader (obfd)->e_flags = new_flags;
9172       elf_elfheader (obfd)->e_ident[EI_CLASS]
9173         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
9174
9175       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
9176           && bfd_get_arch_info (obfd)->the_default)
9177         {
9178           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
9179                                    bfd_get_mach (ibfd)))
9180             return FALSE;
9181         }
9182
9183       return TRUE;
9184     }
9185
9186   /* Check flag compatibility.  */
9187
9188   new_flags &= ~EF_MIPS_NOREORDER;
9189   old_flags &= ~EF_MIPS_NOREORDER;
9190
9191   /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
9192      doesn't seem to matter.  */
9193   new_flags &= ~EF_MIPS_XGOT;
9194   old_flags &= ~EF_MIPS_XGOT;
9195
9196   if (new_flags == old_flags)
9197     return TRUE;
9198
9199   /* Check to see if the input BFD actually contains any sections.
9200      If not, its flags may not have been initialised either, but it cannot
9201      actually cause any incompatibility.  */
9202   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9203     {
9204       /* Ignore synthetic sections and empty .text, .data and .bss sections
9205           which are automatically generated by gas.  */
9206       if (strcmp (sec->name, ".reginfo")
9207           && strcmp (sec->name, ".mdebug")
9208           && ((!strcmp (sec->name, ".text")
9209                || !strcmp (sec->name, ".data")
9210                || !strcmp (sec->name, ".bss"))
9211               && sec->_raw_size != 0))
9212         {
9213           null_input_bfd = FALSE;
9214           break;
9215         }
9216     }
9217   if (null_input_bfd)
9218     return TRUE;
9219
9220   ok = TRUE;
9221
9222   if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
9223       != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
9224     {
9225       (*_bfd_error_handler)
9226         (_("%s: warning: linking PIC files with non-PIC files"),
9227          bfd_archive_filename (ibfd));
9228       ok = TRUE;
9229     }
9230
9231   if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
9232     elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
9233   if (! (new_flags & EF_MIPS_PIC))
9234     elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
9235
9236   new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9237   old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9238
9239   /* Compare the ISAs.  */
9240   if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
9241     {
9242       (*_bfd_error_handler)
9243         (_("%s: linking 32-bit code with 64-bit code"),
9244          bfd_archive_filename (ibfd));
9245       ok = FALSE;
9246     }
9247   else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
9248     {
9249       /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
9250       if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
9251         {
9252           /* Copy the architecture info from IBFD to OBFD.  Also copy
9253              the 32-bit flag (if set) so that we continue to recognise
9254              OBFD as a 32-bit binary.  */
9255           bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
9256           elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
9257           elf_elfheader (obfd)->e_flags
9258             |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9259
9260           /* Copy across the ABI flags if OBFD doesn't use them
9261              and if that was what caused us to treat IBFD as 32-bit.  */
9262           if ((old_flags & EF_MIPS_ABI) == 0
9263               && mips_32bit_flags_p (new_flags)
9264               && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
9265             elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
9266         }
9267       else
9268         {
9269           /* The ISAs aren't compatible.  */
9270           (*_bfd_error_handler)
9271             (_("%s: linking %s module with previous %s modules"),
9272              bfd_archive_filename (ibfd),
9273              bfd_printable_name (ibfd),
9274              bfd_printable_name (obfd));
9275           ok = FALSE;
9276         }
9277     }
9278
9279   new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9280   old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9281
9282   /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
9283      does set EI_CLASS differently from any 32-bit ABI.  */
9284   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
9285       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9286           != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9287     {
9288       /* Only error if both are set (to different values).  */
9289       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
9290           || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9291               != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9292         {
9293           (*_bfd_error_handler)
9294             (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9295              bfd_archive_filename (ibfd),
9296              elf_mips_abi_name (ibfd),
9297              elf_mips_abi_name (obfd));
9298           ok = FALSE;
9299         }
9300       new_flags &= ~EF_MIPS_ABI;
9301       old_flags &= ~EF_MIPS_ABI;
9302     }
9303
9304   /* For now, allow arbitrary mixing of ASEs (retain the union).  */
9305   if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
9306     {
9307       elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
9308
9309       new_flags &= ~ EF_MIPS_ARCH_ASE;
9310       old_flags &= ~ EF_MIPS_ARCH_ASE;
9311     }
9312
9313   /* Warn about any other mismatches */
9314   if (new_flags != old_flags)
9315     {
9316       (*_bfd_error_handler)
9317         (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9318          bfd_archive_filename (ibfd), (unsigned long) new_flags,
9319          (unsigned long) old_flags);
9320       ok = FALSE;
9321     }
9322
9323   if (! ok)
9324     {
9325       bfd_set_error (bfd_error_bad_value);
9326       return FALSE;
9327     }
9328
9329   return TRUE;
9330 }
9331
9332 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
9333
9334 bfd_boolean
9335 _bfd_mips_elf_set_private_flags (abfd, flags)
9336      bfd *abfd;
9337      flagword flags;
9338 {
9339   BFD_ASSERT (!elf_flags_init (abfd)
9340               || elf_elfheader (abfd)->e_flags == flags);
9341
9342   elf_elfheader (abfd)->e_flags = flags;
9343   elf_flags_init (abfd) = TRUE;
9344   return TRUE;
9345 }
9346
9347 bfd_boolean
9348 _bfd_mips_elf_print_private_bfd_data (abfd, ptr)
9349      bfd *abfd;
9350      PTR ptr;
9351 {
9352   FILE *file = (FILE *) ptr;
9353
9354   BFD_ASSERT (abfd != NULL && ptr != NULL);
9355
9356   /* Print normal ELF private data.  */
9357   _bfd_elf_print_private_bfd_data (abfd, ptr);
9358
9359   /* xgettext:c-format */
9360   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
9361
9362   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
9363     fprintf (file, _(" [abi=O32]"));
9364   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
9365     fprintf (file, _(" [abi=O64]"));
9366   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
9367     fprintf (file, _(" [abi=EABI32]"));
9368   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
9369     fprintf (file, _(" [abi=EABI64]"));
9370   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
9371     fprintf (file, _(" [abi unknown]"));
9372   else if (ABI_N32_P (abfd))
9373     fprintf (file, _(" [abi=N32]"));
9374   else if (ABI_64_P (abfd))
9375     fprintf (file, _(" [abi=64]"));
9376   else
9377     fprintf (file, _(" [no abi set]"));
9378
9379   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
9380     fprintf (file, _(" [mips1]"));
9381   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
9382     fprintf (file, _(" [mips2]"));
9383   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
9384     fprintf (file, _(" [mips3]"));
9385   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
9386     fprintf (file, _(" [mips4]"));
9387   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
9388     fprintf (file, _(" [mips5]"));
9389   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
9390     fprintf (file, _(" [mips32]"));
9391   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
9392     fprintf (file, _(" [mips64]"));
9393   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
9394     fprintf (file, _(" [mips32r2]"));
9395   else
9396     fprintf (file, _(" [unknown ISA]"));
9397
9398   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
9399     fprintf (file, _(" [mdmx]"));
9400
9401   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
9402     fprintf (file, _(" [mips16]"));
9403
9404   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
9405     fprintf (file, _(" [32bitmode]"));
9406   else
9407     fprintf (file, _(" [not 32bitmode]"));
9408
9409   fputc ('\n', file);
9410
9411   return TRUE;
9412 }