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   /* We have to use an alignment of 2**4 here because this is hardcoded
2874      in the function stub generation and in the linker script.  */
2875   s = bfd_make_section (abfd, ".got");
2876   if (s == NULL
2877       || ! bfd_set_section_flags (abfd, s, flags)
2878       || ! bfd_set_section_alignment (abfd, s, 4))
2879     return FALSE;
2880
2881   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
2882      linker script because we don't want to define the symbol if we
2883      are not creating a global offset table.  */
2884   bh = NULL;
2885   if (! (_bfd_generic_link_add_one_symbol
2886          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
2887           (bfd_vma) 0, (const char *) NULL, FALSE,
2888           get_elf_backend_data (abfd)->collect, &bh)))
2889     return FALSE;
2890
2891   h = (struct elf_link_hash_entry *) bh;
2892   h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
2893   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2894   h->type = STT_OBJECT;
2895
2896   if (info->shared
2897       && ! bfd_elf32_link_record_dynamic_symbol (info, h))
2898     return FALSE;
2899
2900   amt = sizeof (struct mips_got_info);
2901   g = (struct mips_got_info *) bfd_alloc (abfd, amt);
2902   if (g == NULL)
2903     return FALSE;
2904   g->global_gotsym = NULL;
2905   g->local_gotno = MIPS_RESERVED_GOTNO;
2906   g->assigned_gotno = MIPS_RESERVED_GOTNO;
2907   g->bfd2got = NULL;
2908   g->next = NULL;
2909   g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
2910                                     mips_elf_got_entry_eq,
2911                                     (htab_del) NULL);
2912   if (g->got_entries == NULL)
2913     return FALSE;
2914   mips_elf_section_data (s)->u.got_info = g;
2915   mips_elf_section_data (s)->elf.this_hdr.sh_flags
2916     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
2917
2918   return TRUE;
2919 }
2920
2921 /* Returns the .msym section for ABFD, creating it if it does not
2922    already exist.  Returns NULL to indicate error.  */
2923
2924 static asection *
2925 mips_elf_create_msym_section (abfd)
2926      bfd *abfd;
2927 {
2928   asection *s;
2929
2930   s = bfd_get_section_by_name (abfd, ".msym");
2931   if (!s)
2932     {
2933       s = bfd_make_section (abfd, ".msym");
2934       if (!s
2935           || !bfd_set_section_flags (abfd, s,
2936                                      SEC_ALLOC
2937                                      | SEC_LOAD
2938                                      | SEC_HAS_CONTENTS
2939                                      | SEC_LINKER_CREATED
2940                                      | SEC_READONLY)
2941           || !bfd_set_section_alignment (abfd, s,
2942                                          MIPS_ELF_LOG_FILE_ALIGN (abfd)))
2943         return NULL;
2944     }
2945
2946   return s;
2947 }
2948 \f
2949 /* Calculate the value produced by the RELOCATION (which comes from
2950    the INPUT_BFD).  The ADDEND is the addend to use for this
2951    RELOCATION; RELOCATION->R_ADDEND is ignored.
2952
2953    The result of the relocation calculation is stored in VALUEP.
2954    REQUIRE_JALXP indicates whether or not the opcode used with this
2955    relocation must be JALX.
2956
2957    This function returns bfd_reloc_continue if the caller need take no
2958    further action regarding this relocation, bfd_reloc_notsupported if
2959    something goes dramatically wrong, bfd_reloc_overflow if an
2960    overflow occurs, and bfd_reloc_ok to indicate success.  */
2961
2962 static bfd_reloc_status_type
2963 mips_elf_calculate_relocation (abfd, input_bfd, input_section, info,
2964                                relocation, addend, howto, local_syms,
2965                                local_sections, valuep, namep,
2966                                require_jalxp, save_addend)
2967      bfd *abfd;
2968      bfd *input_bfd;
2969      asection *input_section;
2970      struct bfd_link_info *info;
2971      const Elf_Internal_Rela *relocation;
2972      bfd_vma addend;
2973      reloc_howto_type *howto;
2974      Elf_Internal_Sym *local_syms;
2975      asection **local_sections;
2976      bfd_vma *valuep;
2977      const char **namep;
2978      bfd_boolean *require_jalxp;
2979      bfd_boolean save_addend;
2980 {
2981   /* The eventual value we will return.  */
2982   bfd_vma value;
2983   /* The address of the symbol against which the relocation is
2984      occurring.  */
2985   bfd_vma symbol = 0;
2986   /* The final GP value to be used for the relocatable, executable, or
2987      shared object file being produced.  */
2988   bfd_vma gp = MINUS_ONE;
2989   /* The place (section offset or address) of the storage unit being
2990      relocated.  */
2991   bfd_vma p;
2992   /* The value of GP used to create the relocatable object.  */
2993   bfd_vma gp0 = MINUS_ONE;
2994   /* The offset into the global offset table at which the address of
2995      the relocation entry symbol, adjusted by the addend, resides
2996      during execution.  */
2997   bfd_vma g = MINUS_ONE;
2998   /* The section in which the symbol referenced by the relocation is
2999      located.  */
3000   asection *sec = NULL;
3001   struct mips_elf_link_hash_entry *h = NULL;
3002   /* TRUE if the symbol referred to by this relocation is a local
3003      symbol.  */
3004   bfd_boolean local_p, was_local_p;
3005   /* TRUE if the symbol referred to by this relocation is "_gp_disp".  */
3006   bfd_boolean gp_disp_p = FALSE;
3007   Elf_Internal_Shdr *symtab_hdr;
3008   size_t extsymoff;
3009   unsigned long r_symndx;
3010   int r_type;
3011   /* TRUE if overflow occurred during the calculation of the
3012      relocation value.  */
3013   bfd_boolean overflowed_p;
3014   /* TRUE if this relocation refers to a MIPS16 function.  */
3015   bfd_boolean target_is_16_bit_code_p = FALSE;
3016
3017   /* Parse the relocation.  */
3018   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
3019   r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
3020   p = (input_section->output_section->vma
3021        + input_section->output_offset
3022        + relocation->r_offset);
3023
3024   /* Assume that there will be no overflow.  */
3025   overflowed_p = FALSE;
3026
3027   /* Figure out whether or not the symbol is local, and get the offset
3028      used in the array of hash table entries.  */
3029   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3030   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
3031                                          local_sections, FALSE);
3032   was_local_p = local_p;
3033   if (! elf_bad_symtab (input_bfd))
3034     extsymoff = symtab_hdr->sh_info;
3035   else
3036     {
3037       /* The symbol table does not follow the rule that local symbols
3038          must come before globals.  */
3039       extsymoff = 0;
3040     }
3041
3042   /* Figure out the value of the symbol.  */
3043   if (local_p)
3044     {
3045       Elf_Internal_Sym *sym;
3046
3047       sym = local_syms + r_symndx;
3048       sec = local_sections[r_symndx];
3049
3050       symbol = sec->output_section->vma + sec->output_offset;
3051       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
3052           || (sec->flags & SEC_MERGE))
3053         symbol += sym->st_value;
3054       if ((sec->flags & SEC_MERGE)
3055           && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3056         {
3057           addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
3058           addend -= symbol;
3059           addend += sec->output_section->vma + sec->output_offset;
3060         }
3061
3062       /* MIPS16 text labels should be treated as odd.  */
3063       if (sym->st_other == STO_MIPS16)
3064         ++symbol;
3065
3066       /* Record the name of this symbol, for our caller.  */
3067       *namep = bfd_elf_string_from_elf_section (input_bfd,
3068                                                 symtab_hdr->sh_link,
3069                                                 sym->st_name);
3070       if (*namep == '\0')
3071         *namep = bfd_section_name (input_bfd, sec);
3072
3073       target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
3074     }
3075   else
3076     {
3077       /* For global symbols we look up the symbol in the hash-table.  */
3078       h = ((struct mips_elf_link_hash_entry *)
3079            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
3080       /* Find the real hash-table entry for this symbol.  */
3081       while (h->root.root.type == bfd_link_hash_indirect
3082              || h->root.root.type == bfd_link_hash_warning)
3083         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3084
3085       /* Record the name of this symbol, for our caller.  */
3086       *namep = h->root.root.root.string;
3087
3088       /* See if this is the special _gp_disp symbol.  Note that such a
3089          symbol must always be a global symbol.  */
3090       if (strcmp (h->root.root.root.string, "_gp_disp") == 0
3091           && ! NEWABI_P (input_bfd))
3092         {
3093           /* Relocations against _gp_disp are permitted only with
3094              R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
3095           if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16)
3096             return bfd_reloc_notsupported;
3097
3098           gp_disp_p = TRUE;
3099         }
3100       /* If this symbol is defined, calculate its address.  Note that
3101          _gp_disp is a magic symbol, always implicitly defined by the
3102          linker, so it's inappropriate to check to see whether or not
3103          its defined.  */
3104       else if ((h->root.root.type == bfd_link_hash_defined
3105                 || h->root.root.type == bfd_link_hash_defweak)
3106                && h->root.root.u.def.section)
3107         {
3108           sec = h->root.root.u.def.section;
3109           if (sec->output_section)
3110             symbol = (h->root.root.u.def.value
3111                       + sec->output_section->vma
3112                       + sec->output_offset);
3113           else
3114             symbol = h->root.root.u.def.value;
3115         }
3116       else if (h->root.root.type == bfd_link_hash_undefweak)
3117         /* We allow relocations against undefined weak symbols, giving
3118            it the value zero, so that you can undefined weak functions
3119            and check to see if they exist by looking at their
3120            addresses.  */
3121         symbol = 0;
3122       else if (info->shared
3123                && !info->no_undefined
3124                && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3125         symbol = 0;
3126       else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0 ||
3127               strcmp (h->root.root.root.string, "_DYNAMIC_LINKING") == 0)
3128         {
3129           /* If this is a dynamic link, we should have created a
3130              _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3131              in in _bfd_mips_elf_create_dynamic_sections.
3132              Otherwise, we should define the symbol with a value of 0.
3133              FIXME: It should probably get into the symbol table
3134              somehow as well.  */
3135           BFD_ASSERT (! info->shared);
3136           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
3137           symbol = 0;
3138         }
3139       else
3140         {
3141           if (! ((*info->callbacks->undefined_symbol)
3142                  (info, h->root.root.root.string, input_bfd,
3143                   input_section, relocation->r_offset,
3144                   (!info->shared || info->no_undefined
3145                    || ELF_ST_VISIBILITY (h->root.other)))))
3146             return bfd_reloc_undefined;
3147           symbol = 0;
3148         }
3149
3150       target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
3151     }
3152
3153   /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3154      need to redirect the call to the stub, unless we're already *in*
3155      a stub.  */
3156   if (r_type != R_MIPS16_26 && !info->relocatable
3157       && ((h != NULL && h->fn_stub != NULL)
3158           || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
3159               && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
3160       && !mips_elf_stub_section_p (input_bfd, input_section))
3161     {
3162       /* This is a 32- or 64-bit call to a 16-bit function.  We should
3163          have already noticed that we were going to need the
3164          stub.  */
3165       if (local_p)
3166         sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
3167       else
3168         {
3169           BFD_ASSERT (h->need_fn_stub);
3170           sec = h->fn_stub;
3171         }
3172
3173       symbol = sec->output_section->vma + sec->output_offset;
3174     }
3175   /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3176      need to redirect the call to the stub.  */
3177   else if (r_type == R_MIPS16_26 && !info->relocatable
3178            && h != NULL
3179            && (h->call_stub != NULL || h->call_fp_stub != NULL)
3180            && !target_is_16_bit_code_p)
3181     {
3182       /* If both call_stub and call_fp_stub are defined, we can figure
3183          out which one to use by seeing which one appears in the input
3184          file.  */
3185       if (h->call_stub != NULL && h->call_fp_stub != NULL)
3186         {
3187           asection *o;
3188
3189           sec = NULL;
3190           for (o = input_bfd->sections; o != NULL; o = o->next)
3191             {
3192               if (strncmp (bfd_get_section_name (input_bfd, o),
3193                            CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
3194                 {
3195                   sec = h->call_fp_stub;
3196                   break;
3197                 }
3198             }
3199           if (sec == NULL)
3200             sec = h->call_stub;
3201         }
3202       else if (h->call_stub != NULL)
3203         sec = h->call_stub;
3204       else
3205         sec = h->call_fp_stub;
3206
3207       BFD_ASSERT (sec->_raw_size > 0);
3208       symbol = sec->output_section->vma + sec->output_offset;
3209     }
3210
3211   /* Calls from 16-bit code to 32-bit code and vice versa require the
3212      special jalx instruction.  */
3213   *require_jalxp = (!info->relocatable
3214                     && (((r_type == R_MIPS16_26) && !target_is_16_bit_code_p)
3215                         || ((r_type == R_MIPS_26) && target_is_16_bit_code_p)));
3216
3217   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
3218                                          local_sections, TRUE);
3219
3220   /* If we haven't already determined the GOT offset, or the GP value,
3221      and we're going to need it, get it now.  */
3222   switch (r_type)
3223     {
3224     case R_MIPS_GOT_PAGE:
3225     case R_MIPS_GOT_OFST:
3226       /* If this symbol got a global GOT entry, we have to decay
3227          GOT_PAGE/GOT_OFST to GOT_DISP/addend.  */
3228       local_p = local_p || ! h
3229         || (h->root.dynindx
3230             < mips_elf_get_global_gotsym_index (elf_hash_table (info)
3231                                                 ->dynobj));
3232       if (local_p || r_type == R_MIPS_GOT_OFST)
3233         break;
3234       /* Fall through.  */
3235
3236     case R_MIPS_CALL16:
3237     case R_MIPS_GOT16:
3238     case R_MIPS_GOT_DISP:
3239     case R_MIPS_GOT_HI16:
3240     case R_MIPS_CALL_HI16:
3241     case R_MIPS_GOT_LO16:
3242     case R_MIPS_CALL_LO16:
3243       /* Find the index into the GOT where this value is located.  */
3244       if (!local_p)
3245         {
3246           /* GOT_PAGE may take a non-zero addend, that is ignored in a
3247              GOT_PAGE relocation that decays to GOT_DISP because the
3248              symbol turns out to be global.  The addend is then added
3249              as GOT_OFST.  */
3250           BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE);
3251           g = mips_elf_global_got_index (elf_hash_table (info)->dynobj,
3252                                          input_bfd,
3253                                          (struct elf_link_hash_entry *) h);
3254           if (! elf_hash_table(info)->dynamic_sections_created
3255               || (info->shared
3256                   && (info->symbolic || h->root.dynindx == -1)
3257                   && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3258             {
3259               /* This is a static link or a -Bsymbolic link.  The
3260                  symbol is defined locally, or was forced to be local.
3261                  We must initialize this entry in the GOT.  */
3262               bfd *tmpbfd = elf_hash_table (info)->dynobj;
3263               asection *sgot = mips_elf_got_section (tmpbfd, FALSE);
3264               MIPS_ELF_PUT_WORD (tmpbfd, symbol, sgot->contents + g);
3265             }
3266         }
3267       else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
3268         /* There's no need to create a local GOT entry here; the
3269            calculation for a local GOT16 entry does not involve G.  */
3270         break;
3271       else
3272         {
3273           g = mips_elf_local_got_index (abfd, input_bfd,
3274                                         info, symbol + addend);
3275           if (g == MINUS_ONE)
3276             return bfd_reloc_outofrange;
3277         }
3278
3279       /* Convert GOT indices to actual offsets.  */
3280       g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3281                                           abfd, input_bfd, g);
3282       break;
3283
3284     case R_MIPS_HI16:
3285     case R_MIPS_LO16:
3286     case R_MIPS16_GPREL:
3287     case R_MIPS_GPREL16:
3288     case R_MIPS_GPREL32:
3289     case R_MIPS_LITERAL:
3290       gp0 = _bfd_get_gp_value (input_bfd);
3291       gp = _bfd_get_gp_value (abfd);
3292       if (elf_hash_table (info)->dynobj)
3293         gp += mips_elf_adjust_gp (abfd,
3294                                   mips_elf_got_info
3295                                   (elf_hash_table (info)->dynobj, NULL),
3296                                   input_bfd);
3297       break;
3298
3299     default:
3300       break;
3301     }
3302
3303   /* Figure out what kind of relocation is being performed.  */
3304   switch (r_type)
3305     {
3306     case R_MIPS_NONE:
3307       return bfd_reloc_continue;
3308
3309     case R_MIPS_16:
3310       value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
3311       overflowed_p = mips_elf_overflow_p (value, 16);
3312       break;
3313
3314     case R_MIPS_32:
3315     case R_MIPS_REL32:
3316     case R_MIPS_64:
3317       if ((info->shared
3318            || (elf_hash_table (info)->dynamic_sections_created
3319                && h != NULL
3320                && ((h->root.elf_link_hash_flags
3321                     & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
3322                && ((h->root.elf_link_hash_flags
3323                     & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3324           && r_symndx != 0
3325           && (input_section->flags & SEC_ALLOC) != 0)
3326         {
3327           /* If we're creating a shared library, or this relocation is
3328              against a symbol in a shared library, then we can't know
3329              where the symbol will end up.  So, we create a relocation
3330              record in the output, and leave the job up to the dynamic
3331              linker.  */
3332           value = addend;
3333           if (!mips_elf_create_dynamic_relocation (abfd,
3334                                                    info,
3335                                                    relocation,
3336                                                    h,
3337                                                    sec,
3338                                                    symbol,
3339                                                    &value,
3340                                                    input_section))
3341             return bfd_reloc_undefined;
3342         }
3343       else
3344         {
3345           if (r_type != R_MIPS_REL32)
3346             value = symbol + addend;
3347           else
3348             value = addend;
3349         }
3350       value &= howto->dst_mask;
3351       break;
3352
3353     case R_MIPS_PC32:
3354     case R_MIPS_PC64:
3355     case R_MIPS_GNU_REL_LO16:
3356       value = symbol + addend - p;
3357       value &= howto->dst_mask;
3358       break;
3359
3360     case R_MIPS_GNU_REL16_S2:
3361       value = symbol + _bfd_mips_elf_sign_extend (addend << 2, 18) - p;
3362       overflowed_p = mips_elf_overflow_p (value, 18);
3363       value = (value >> 2) & howto->dst_mask;
3364       break;
3365
3366     case R_MIPS_GNU_REL_HI16:
3367       /* Instead of subtracting 'p' here, we should be subtracting the
3368          equivalent value for the LO part of the reloc, since the value
3369          here is relative to that address.  Because that's not easy to do,
3370          we adjust 'addend' in _bfd_mips_elf_relocate_section().  See also
3371          the comment there for more information.  */
3372       value = mips_elf_high (addend + symbol - p);
3373       value &= howto->dst_mask;
3374       break;
3375
3376     case R_MIPS16_26:
3377       /* The calculation for R_MIPS16_26 is just the same as for an
3378          R_MIPS_26.  It's only the storage of the relocated field into
3379          the output file that's different.  That's handled in
3380          mips_elf_perform_relocation.  So, we just fall through to the
3381          R_MIPS_26 case here.  */
3382     case R_MIPS_26:
3383       if (local_p)
3384         value = (((addend << 2) | ((p + 4) & 0xf0000000)) + symbol) >> 2;
3385       else
3386         value = (_bfd_mips_elf_sign_extend (addend << 2, 28) + symbol) >> 2;
3387       value &= howto->dst_mask;
3388       break;
3389
3390     case R_MIPS_HI16:
3391       if (!gp_disp_p)
3392         {
3393           value = mips_elf_high (addend + symbol);
3394           value &= howto->dst_mask;
3395         }
3396       else
3397         {
3398           value = mips_elf_high (addend + gp - p);
3399           overflowed_p = mips_elf_overflow_p (value, 16);
3400         }
3401       break;
3402
3403     case R_MIPS_LO16:
3404       if (!gp_disp_p)
3405         value = (symbol + addend) & howto->dst_mask;
3406       else
3407         {
3408           value = addend + gp - p + 4;
3409           /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3410              for overflow.  But, on, say, IRIX5, relocations against
3411              _gp_disp are normally generated from the .cpload
3412              pseudo-op.  It generates code that normally looks like
3413              this:
3414
3415                lui    $gp,%hi(_gp_disp)
3416                addiu  $gp,$gp,%lo(_gp_disp)
3417                addu   $gp,$gp,$t9
3418
3419              Here $t9 holds the address of the function being called,
3420              as required by the MIPS ELF ABI.  The R_MIPS_LO16
3421              relocation can easily overflow in this situation, but the
3422              R_MIPS_HI16 relocation will handle the overflow.
3423              Therefore, we consider this a bug in the MIPS ABI, and do
3424              not check for overflow here.  */
3425         }
3426       break;
3427
3428     case R_MIPS_LITERAL:
3429       /* Because we don't merge literal sections, we can handle this
3430          just like R_MIPS_GPREL16.  In the long run, we should merge
3431          shared literals, and then we will need to additional work
3432          here.  */
3433
3434       /* Fall through.  */
3435
3436     case R_MIPS16_GPREL:
3437       /* The R_MIPS16_GPREL performs the same calculation as
3438          R_MIPS_GPREL16, but stores the relocated bits in a different
3439          order.  We don't need to do anything special here; the
3440          differences are handled in mips_elf_perform_relocation.  */
3441     case R_MIPS_GPREL16:
3442       /* Only sign-extend the addend if it was extracted from the
3443          instruction.  If the addend was separate, leave it alone,
3444          otherwise we may lose significant bits.  */
3445       if (howto->partial_inplace)
3446         addend = _bfd_mips_elf_sign_extend (addend, 16);
3447       value = symbol + addend - gp;
3448       /* If the symbol was local, any earlier relocatable links will
3449          have adjusted its addend with the gp offset, so compensate
3450          for that now.  Don't do it for symbols forced local in this
3451          link, though, since they won't have had the gp offset applied
3452          to them before.  */
3453       if (was_local_p)
3454         value += gp0;
3455       overflowed_p = mips_elf_overflow_p (value, 16);
3456       break;
3457
3458     case R_MIPS_GOT16:
3459     case R_MIPS_CALL16:
3460       if (local_p)
3461         {
3462           bfd_boolean forced;
3463
3464           /* The special case is when the symbol is forced to be local.  We
3465              need the full address in the GOT since no R_MIPS_LO16 relocation
3466              follows.  */
3467           forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
3468                                                   local_sections, FALSE);
3469           value = mips_elf_got16_entry (abfd, input_bfd, info,
3470                                         symbol + addend, forced);
3471           if (value == MINUS_ONE)
3472             return bfd_reloc_outofrange;
3473           value
3474             = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3475                                               abfd, input_bfd, value);
3476           overflowed_p = mips_elf_overflow_p (value, 16);
3477           break;
3478         }
3479
3480       /* Fall through.  */
3481
3482     case R_MIPS_GOT_DISP:
3483     got_disp:
3484       value = g;
3485       overflowed_p = mips_elf_overflow_p (value, 16);
3486       break;
3487
3488     case R_MIPS_GPREL32:
3489       value = (addend + symbol + gp0 - gp);
3490       if (!save_addend)
3491         value &= howto->dst_mask;
3492       break;
3493
3494     case R_MIPS_PC16:
3495       value = _bfd_mips_elf_sign_extend (addend, 16) + symbol - p;
3496       overflowed_p = mips_elf_overflow_p (value, 16);
3497       break;
3498
3499     case R_MIPS_GOT_HI16:
3500     case R_MIPS_CALL_HI16:
3501       /* We're allowed to handle these two relocations identically.
3502          The dynamic linker is allowed to handle the CALL relocations
3503          differently by creating a lazy evaluation stub.  */
3504       value = g;
3505       value = mips_elf_high (value);
3506       value &= howto->dst_mask;
3507       break;
3508
3509     case R_MIPS_GOT_LO16:
3510     case R_MIPS_CALL_LO16:
3511       value = g & howto->dst_mask;
3512       break;
3513
3514     case R_MIPS_GOT_PAGE:
3515       /* GOT_PAGE relocations that reference non-local symbols decay
3516          to GOT_DISP.  The corresponding GOT_OFST relocation decays to
3517          0.  */
3518       if (! local_p)
3519         goto got_disp;
3520       value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
3521       if (value == MINUS_ONE)
3522         return bfd_reloc_outofrange;
3523       value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3524                                               abfd, input_bfd, value);
3525       overflowed_p = mips_elf_overflow_p (value, 16);
3526       break;
3527
3528     case R_MIPS_GOT_OFST:
3529       if (local_p)
3530         mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
3531       else
3532         value = addend;
3533       overflowed_p = mips_elf_overflow_p (value, 16);
3534       break;
3535
3536     case R_MIPS_SUB:
3537       value = symbol - addend;
3538       value &= howto->dst_mask;
3539       break;
3540
3541     case R_MIPS_HIGHER:
3542       value = mips_elf_higher (addend + symbol);
3543       value &= howto->dst_mask;
3544       break;
3545
3546     case R_MIPS_HIGHEST:
3547       value = mips_elf_highest (addend + symbol);
3548       value &= howto->dst_mask;
3549       break;
3550
3551     case R_MIPS_SCN_DISP:
3552       value = symbol + addend - sec->output_offset;
3553       value &= howto->dst_mask;
3554       break;
3555
3556     case R_MIPS_PJUMP:
3557     case R_MIPS_JALR:
3558       /* Both of these may be ignored.  R_MIPS_JALR is an optimization
3559          hint; we could improve performance by honoring that hint.  */
3560       return bfd_reloc_continue;
3561
3562     case R_MIPS_GNU_VTINHERIT:
3563     case R_MIPS_GNU_VTENTRY:
3564       /* We don't do anything with these at present.  */
3565       return bfd_reloc_continue;
3566
3567     default:
3568       /* An unrecognized relocation type.  */
3569       return bfd_reloc_notsupported;
3570     }
3571
3572   /* Store the VALUE for our caller.  */
3573   *valuep = value;
3574   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
3575 }
3576
3577 /* Obtain the field relocated by RELOCATION.  */
3578
3579 static bfd_vma
3580 mips_elf_obtain_contents (howto, relocation, input_bfd, contents)
3581      reloc_howto_type *howto;
3582      const Elf_Internal_Rela *relocation;
3583      bfd *input_bfd;
3584      bfd_byte *contents;
3585 {
3586   bfd_vma x;
3587   bfd_byte *location = contents + relocation->r_offset;
3588
3589   /* Obtain the bytes.  */
3590   x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
3591
3592   if ((ELF_R_TYPE (input_bfd, relocation->r_info) == R_MIPS16_26
3593        || ELF_R_TYPE (input_bfd, relocation->r_info) == R_MIPS16_GPREL)
3594       && bfd_little_endian (input_bfd))
3595     /* The two 16-bit words will be reversed on a little-endian system.
3596        See mips_elf_perform_relocation for more details.  */
3597     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
3598
3599   return x;
3600 }
3601
3602 /* It has been determined that the result of the RELOCATION is the
3603    VALUE.  Use HOWTO to place VALUE into the output file at the
3604    appropriate position.  The SECTION is the section to which the
3605    relocation applies.  If REQUIRE_JALX is TRUE, then the opcode used
3606    for the relocation must be either JAL or JALX, and it is
3607    unconditionally converted to JALX.
3608
3609    Returns FALSE if anything goes wrong.  */
3610
3611 static bfd_boolean
3612 mips_elf_perform_relocation (info, howto, relocation, value, input_bfd,
3613                              input_section, contents, require_jalx)
3614      struct bfd_link_info *info;
3615      reloc_howto_type *howto;
3616      const Elf_Internal_Rela *relocation;
3617      bfd_vma value;
3618      bfd *input_bfd;
3619      asection *input_section;
3620      bfd_byte *contents;
3621      bfd_boolean require_jalx;
3622 {
3623   bfd_vma x;
3624   bfd_byte *location;
3625   int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
3626
3627   /* Figure out where the relocation is occurring.  */
3628   location = contents + relocation->r_offset;
3629
3630   /* Obtain the current value.  */
3631   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
3632
3633   /* Clear the field we are setting.  */
3634   x &= ~howto->dst_mask;
3635
3636   /* If this is the R_MIPS16_26 relocation, we must store the
3637      value in a funny way.  */
3638   if (r_type == R_MIPS16_26)
3639     {
3640       /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3641          Most mips16 instructions are 16 bits, but these instructions
3642          are 32 bits.
3643
3644          The format of these instructions is:
3645
3646          +--------------+--------------------------------+
3647          !     JALX     ! X!   Imm 20:16  !   Imm 25:21  !
3648          +--------------+--------------------------------+
3649          !                Immediate  15:0                   !
3650          +-----------------------------------------------+
3651
3652          JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
3653          Note that the immediate value in the first word is swapped.
3654
3655          When producing a relocatable object file, R_MIPS16_26 is
3656          handled mostly like R_MIPS_26.  In particular, the addend is
3657          stored as a straight 26-bit value in a 32-bit instruction.
3658          (gas makes life simpler for itself by never adjusting a
3659          R_MIPS16_26 reloc to be against a section, so the addend is
3660          always zero).  However, the 32 bit instruction is stored as 2
3661          16-bit values, rather than a single 32-bit value.  In a
3662          big-endian file, the result is the same; in a little-endian
3663          file, the two 16-bit halves of the 32 bit value are swapped.
3664          This is so that a disassembler can recognize the jal
3665          instruction.
3666
3667          When doing a final link, R_MIPS16_26 is treated as a 32 bit
3668          instruction stored as two 16-bit values.  The addend A is the
3669          contents of the targ26 field.  The calculation is the same as
3670          R_MIPS_26.  When storing the calculated value, reorder the
3671          immediate value as shown above, and don't forget to store the
3672          value as two 16-bit values.
3673
3674          To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3675          defined as
3676
3677          big-endian:
3678          +--------+----------------------+
3679          |        |                      |
3680          |        |    targ26-16         |
3681          |31    26|25                   0|
3682          +--------+----------------------+
3683
3684          little-endian:
3685          +----------+------+-------------+
3686          |          |      |             |
3687          |  sub1    |      |     sub2    |
3688          |0        9|10  15|16         31|
3689          +----------+--------------------+
3690          where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3691          ((sub1 << 16) | sub2)).
3692
3693          When producing a relocatable object file, the calculation is
3694          (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3695          When producing a fully linked file, the calculation is
3696          let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3697          ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)  */
3698
3699       if (!info->relocatable)
3700         /* Shuffle the bits according to the formula above.  */
3701         value = (((value & 0x1f0000) << 5)
3702                  | ((value & 0x3e00000) >> 5)
3703                  | (value & 0xffff));
3704     }
3705   else if (r_type == R_MIPS16_GPREL)
3706     {
3707       /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3708          mode.  A typical instruction will have a format like this:
3709
3710          +--------------+--------------------------------+
3711          !    EXTEND    !     Imm 10:5    !   Imm 15:11  !
3712          +--------------+--------------------------------+
3713          !    Major     !   rx   !   ry   !   Imm  4:0   !
3714          +--------------+--------------------------------+
3715
3716          EXTEND is the five bit value 11110.  Major is the instruction
3717          opcode.
3718
3719          This is handled exactly like R_MIPS_GPREL16, except that the
3720          addend is retrieved and stored as shown in this diagram; that
3721          is, the Imm fields above replace the V-rel16 field.
3722
3723          All we need to do here is shuffle the bits appropriately.  As
3724          above, the two 16-bit halves must be swapped on a
3725          little-endian system.  */
3726       value = (((value & 0x7e0) << 16)
3727                | ((value & 0xf800) << 5)
3728                | (value & 0x1f));
3729     }
3730
3731   /* Set the field.  */
3732   x |= (value & howto->dst_mask);
3733
3734   /* If required, turn JAL into JALX.  */
3735   if (require_jalx)
3736     {
3737       bfd_boolean ok;
3738       bfd_vma opcode = x >> 26;
3739       bfd_vma jalx_opcode;
3740
3741       /* Check to see if the opcode is already JAL or JALX.  */
3742       if (r_type == R_MIPS16_26)
3743         {
3744           ok = ((opcode == 0x6) || (opcode == 0x7));
3745           jalx_opcode = 0x7;
3746         }
3747       else
3748         {
3749           ok = ((opcode == 0x3) || (opcode == 0x1d));
3750           jalx_opcode = 0x1d;
3751         }
3752
3753       /* If the opcode is not JAL or JALX, there's a problem.  */
3754       if (!ok)
3755         {
3756           (*_bfd_error_handler)
3757             (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3758              bfd_archive_filename (input_bfd),
3759              input_section->name,
3760              (unsigned long) relocation->r_offset);
3761           bfd_set_error (bfd_error_bad_value);
3762           return FALSE;
3763         }
3764
3765       /* Make this the JALX opcode.  */
3766       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
3767     }
3768
3769   /* Swap the high- and low-order 16 bits on little-endian systems
3770      when doing a MIPS16 relocation.  */
3771   if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
3772       && bfd_little_endian (input_bfd))
3773     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
3774
3775   /* Put the value into the output.  */
3776   bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
3777   return TRUE;
3778 }
3779
3780 /* Returns TRUE if SECTION is a MIPS16 stub section.  */
3781
3782 static bfd_boolean
3783 mips_elf_stub_section_p (abfd, section)
3784      bfd *abfd ATTRIBUTE_UNUSED;
3785      asection *section;
3786 {
3787   const char *name = bfd_get_section_name (abfd, section);
3788
3789   return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
3790           || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
3791           || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
3792 }
3793 \f
3794 /* Add room for N relocations to the .rel.dyn section in ABFD.  */
3795
3796 static void
3797 mips_elf_allocate_dynamic_relocations (abfd, n)
3798      bfd *abfd;
3799      unsigned int n;
3800 {
3801   asection *s;
3802
3803   s = mips_elf_rel_dyn_section (abfd, FALSE);
3804   BFD_ASSERT (s != NULL);
3805
3806   if (s->_raw_size == 0)
3807     {
3808       /* Make room for a null element.  */
3809       s->_raw_size += MIPS_ELF_REL_SIZE (abfd);
3810       ++s->reloc_count;
3811     }
3812   s->_raw_size += n * MIPS_ELF_REL_SIZE (abfd);
3813 }
3814
3815 /* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
3816    is the original relocation, which is now being transformed into a
3817    dynamic relocation.  The ADDENDP is adjusted if necessary; the
3818    caller should store the result in place of the original addend.  */
3819
3820 static bfd_boolean
3821 mips_elf_create_dynamic_relocation (output_bfd, info, rel, h, sec,
3822                                     symbol, addendp, input_section)
3823      bfd *output_bfd;
3824      struct bfd_link_info *info;
3825      const Elf_Internal_Rela *rel;
3826      struct mips_elf_link_hash_entry *h;
3827      asection *sec;
3828      bfd_vma symbol;
3829      bfd_vma *addendp;
3830      asection *input_section;
3831 {
3832   Elf_Internal_Rela outrel[3];
3833   bfd_boolean skip;
3834   asection *sreloc;
3835   bfd *dynobj;
3836   int r_type;
3837
3838   r_type = ELF_R_TYPE (output_bfd, rel->r_info);
3839   dynobj = elf_hash_table (info)->dynobj;
3840   sreloc = mips_elf_rel_dyn_section (dynobj, FALSE);
3841   BFD_ASSERT (sreloc != NULL);
3842   BFD_ASSERT (sreloc->contents != NULL);
3843   BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
3844               < sreloc->_raw_size);
3845
3846   skip = FALSE;
3847   outrel[0].r_offset =
3848     _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
3849   outrel[1].r_offset =
3850     _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
3851   outrel[2].r_offset =
3852     _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
3853
3854 #if 0
3855   /* We begin by assuming that the offset for the dynamic relocation
3856      is the same as for the original relocation.  We'll adjust this
3857      later to reflect the correct output offsets.  */
3858   if (input_section->sec_info_type != ELF_INFO_TYPE_STABS)
3859     {
3860       outrel[1].r_offset = rel[1].r_offset;
3861       outrel[2].r_offset = rel[2].r_offset;
3862     }
3863   else
3864     {
3865       /* Except that in a stab section things are more complex.
3866          Because we compress stab information, the offset given in the
3867          relocation may not be the one we want; we must let the stabs
3868          machinery tell us the offset.  */
3869       outrel[1].r_offset = outrel[0].r_offset;
3870       outrel[2].r_offset = outrel[0].r_offset;
3871       /* If we didn't need the relocation at all, this value will be
3872          -1.  */
3873       if (outrel[0].r_offset == (bfd_vma) -1)
3874         skip = TRUE;
3875     }
3876 #endif
3877
3878   if (outrel[0].r_offset == (bfd_vma) -1
3879       || outrel[0].r_offset == (bfd_vma) -2)
3880     skip = TRUE;
3881
3882   /* If we've decided to skip this relocation, just output an empty
3883      record.  Note that R_MIPS_NONE == 0, so that this call to memset
3884      is a way of setting R_TYPE to R_MIPS_NONE.  */
3885   if (skip)
3886     memset (outrel, 0, sizeof (Elf_Internal_Rela) * 3);
3887   else
3888     {
3889       long indx;
3890       bfd_boolean defined_p;
3891
3892       /* We must now calculate the dynamic symbol table index to use
3893          in the relocation.  */
3894       if (h != NULL
3895           && (! info->symbolic || (h->root.elf_link_hash_flags
3896                                    & ELF_LINK_HASH_DEF_REGULAR) == 0))
3897         {
3898           indx = h->root.dynindx;
3899           /* h->root.dynindx may be -1 if this symbol was marked to
3900              become local.  */
3901           if (indx == -1)
3902             indx = 0;
3903           if (SGI_COMPAT (output_bfd))
3904             defined_p = ((h->root.elf_link_hash_flags
3905                           & ELF_LINK_HASH_DEF_REGULAR) != 0);
3906           else
3907             /* ??? glibc's ld.so just adds the final GOT entry to the
3908                relocation field.  It therefore treats relocs against
3909                defined symbols in the same way as relocs against
3910                undefined symbols.  */
3911             defined_p = FALSE;
3912         }
3913       else
3914         {
3915           if (sec != NULL && bfd_is_abs_section (sec))
3916             indx = 0;
3917           else if (sec == NULL || sec->owner == NULL)
3918             {
3919               bfd_set_error (bfd_error_bad_value);
3920               return FALSE;
3921             }
3922           else
3923             {
3924               indx = elf_section_data (sec->output_section)->dynindx;
3925               if (indx == 0)
3926                 abort ();
3927             }
3928
3929           /* Instead of generating a relocation using the section
3930              symbol, we may as well make it a fully relative
3931              relocation.  We want to avoid generating relocations to
3932              local symbols because we used to generate them
3933              incorrectly, without adding the original symbol value,
3934              which is mandated by the ABI for section symbols.  In
3935              order to give dynamic loaders and applications time to
3936              phase out the incorrect use, we refrain from emitting
3937              section-relative relocations.  It's not like they're
3938              useful, after all.  This should be a bit more efficient
3939              as well.  */
3940           indx = 0;
3941           defined_p = TRUE;
3942         }
3943
3944       /* If the relocation was previously an absolute relocation and
3945          this symbol will not be referred to by the relocation, we must
3946          adjust it by the value we give it in the dynamic symbol table.
3947          Otherwise leave the job up to the dynamic linker.  */
3948       if (defined_p && r_type != R_MIPS_REL32)
3949         *addendp += symbol;
3950
3951       /* The relocation is always an REL32 relocation because we don't
3952          know where the shared library will wind up at load-time.  */
3953       outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
3954                                      R_MIPS_REL32);
3955       /* For strict adherence to the ABI specification, we should
3956          generate a R_MIPS_64 relocation record by itself before the
3957          _REL32/_64 record as well, such that the addend is read in as
3958          a 64-bit value (REL32 is a 32-bit relocation, after all).
3959          However, since none of the existing ELF64 MIPS dynamic
3960          loaders seems to care, we don't waste space with these
3961          artificial relocations.  If this turns out to not be true,
3962          mips_elf_allocate_dynamic_relocation() should be tweaked so
3963          as to make room for a pair of dynamic relocations per
3964          invocation if ABI_64_P, and here we should generate an
3965          additional relocation record with R_MIPS_64 by itself for a
3966          NULL symbol before this relocation record.  */
3967       outrel[1].r_info = ELF_R_INFO (output_bfd, (unsigned long) 0,
3968                                      ABI_64_P (output_bfd)
3969                                      ? R_MIPS_64
3970                                      : R_MIPS_NONE);
3971       outrel[2].r_info = ELF_R_INFO (output_bfd, (unsigned long) 0,
3972                                      R_MIPS_NONE);
3973
3974       /* Adjust the output offset of the relocation to reference the
3975          correct location in the output file.  */
3976       outrel[0].r_offset += (input_section->output_section->vma
3977                              + input_section->output_offset);
3978       outrel[1].r_offset += (input_section->output_section->vma
3979                              + input_section->output_offset);
3980       outrel[2].r_offset += (input_section->output_section->vma
3981                              + input_section->output_offset);
3982     }
3983
3984   /* Put the relocation back out.  We have to use the special
3985      relocation outputter in the 64-bit case since the 64-bit
3986      relocation format is non-standard.  */
3987   if (ABI_64_P (output_bfd))
3988     {
3989       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3990         (output_bfd, &outrel[0],
3991          (sreloc->contents
3992           + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
3993     }
3994   else
3995     bfd_elf32_swap_reloc_out
3996       (output_bfd, &outrel[0],
3997        (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
3998
3999   /* Record the index of the first relocation referencing H.  This
4000      information is later emitted in the .msym section.  */
4001   if (h != NULL
4002       && (h->min_dyn_reloc_index == 0
4003           || sreloc->reloc_count < h->min_dyn_reloc_index))
4004     h->min_dyn_reloc_index = sreloc->reloc_count;
4005
4006   /* We've now added another relocation.  */
4007   ++sreloc->reloc_count;
4008
4009   /* Make sure the output section is writable.  The dynamic linker
4010      will be writing to it.  */
4011   elf_section_data (input_section->output_section)->this_hdr.sh_flags
4012     |= SHF_WRITE;
4013
4014   /* On IRIX5, make an entry of compact relocation info.  */
4015   if (! skip && IRIX_COMPAT (output_bfd) == ict_irix5)
4016     {
4017       asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
4018       bfd_byte *cr;
4019
4020       if (scpt)
4021         {
4022           Elf32_crinfo cptrel;
4023
4024           mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
4025           cptrel.vaddr = (rel->r_offset
4026                           + input_section->output_section->vma
4027                           + input_section->output_offset);
4028           if (r_type == R_MIPS_REL32)
4029             mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
4030           else
4031             mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
4032           mips_elf_set_cr_dist2to (cptrel, 0);
4033           cptrel.konst = *addendp;
4034
4035           cr = (scpt->contents
4036                 + sizeof (Elf32_External_compact_rel));
4037           bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
4038                                      ((Elf32_External_crinfo *) cr
4039                                       + scpt->reloc_count));
4040           ++scpt->reloc_count;
4041         }
4042     }
4043
4044   return TRUE;
4045 }
4046 \f
4047 /* Return the MACH for a MIPS e_flags value.  */
4048
4049 unsigned long
4050 _bfd_elf_mips_mach (flags)
4051      flagword flags;
4052 {
4053   switch (flags & EF_MIPS_MACH)
4054     {
4055     case E_MIPS_MACH_3900:
4056       return bfd_mach_mips3900;
4057
4058     case E_MIPS_MACH_4010:
4059       return bfd_mach_mips4010;
4060
4061     case E_MIPS_MACH_4100:
4062       return bfd_mach_mips4100;
4063
4064     case E_MIPS_MACH_4111:
4065       return bfd_mach_mips4111;
4066
4067     case E_MIPS_MACH_4120:
4068       return bfd_mach_mips4120;
4069
4070     case E_MIPS_MACH_4650:
4071       return bfd_mach_mips4650;
4072
4073     case E_MIPS_MACH_5400:
4074       return bfd_mach_mips5400;
4075
4076     case E_MIPS_MACH_5500:
4077       return bfd_mach_mips5500;
4078
4079     case E_MIPS_MACH_SB1:
4080       return bfd_mach_mips_sb1;
4081
4082     default:
4083       switch (flags & EF_MIPS_ARCH)
4084         {
4085         default:
4086         case E_MIPS_ARCH_1:
4087           return bfd_mach_mips3000;
4088           break;
4089
4090         case E_MIPS_ARCH_2:
4091           return bfd_mach_mips6000;
4092           break;
4093
4094         case E_MIPS_ARCH_3:
4095           return bfd_mach_mips4000;
4096           break;
4097
4098         case E_MIPS_ARCH_4:
4099           return bfd_mach_mips8000;
4100           break;
4101
4102         case E_MIPS_ARCH_5:
4103           return bfd_mach_mips5;
4104           break;
4105
4106         case E_MIPS_ARCH_32:
4107           return bfd_mach_mipsisa32;
4108           break;
4109
4110         case E_MIPS_ARCH_64:
4111           return bfd_mach_mipsisa64;
4112           break;
4113
4114         case E_MIPS_ARCH_32R2:
4115           return bfd_mach_mipsisa32r2;
4116           break;
4117         }
4118     }
4119
4120   return 0;
4121 }
4122
4123 /* Return printable name for ABI.  */
4124
4125 static INLINE char *
4126 elf_mips_abi_name (abfd)
4127      bfd *abfd;
4128 {
4129   flagword flags;
4130
4131   flags = elf_elfheader (abfd)->e_flags;
4132   switch (flags & EF_MIPS_ABI)
4133     {
4134     case 0:
4135       if (ABI_N32_P (abfd))
4136         return "N32";
4137       else if (ABI_64_P (abfd))
4138         return "64";
4139       else
4140         return "none";
4141     case E_MIPS_ABI_O32:
4142       return "O32";
4143     case E_MIPS_ABI_O64:
4144       return "O64";
4145     case E_MIPS_ABI_EABI32:
4146       return "EABI32";
4147     case E_MIPS_ABI_EABI64:
4148       return "EABI64";
4149     default:
4150       return "unknown abi";
4151     }
4152 }
4153 \f
4154 /* MIPS ELF uses two common sections.  One is the usual one, and the
4155    other is for small objects.  All the small objects are kept
4156    together, and then referenced via the gp pointer, which yields
4157    faster assembler code.  This is what we use for the small common
4158    section.  This approach is copied from ecoff.c.  */
4159 static asection mips_elf_scom_section;
4160 static asymbol mips_elf_scom_symbol;
4161 static asymbol *mips_elf_scom_symbol_ptr;
4162
4163 /* MIPS ELF also uses an acommon section, which represents an
4164    allocated common symbol which may be overridden by a
4165    definition in a shared library.  */
4166 static asection mips_elf_acom_section;
4167 static asymbol mips_elf_acom_symbol;
4168 static asymbol *mips_elf_acom_symbol_ptr;
4169
4170 /* Handle the special MIPS section numbers that a symbol may use.
4171    This is used for both the 32-bit and the 64-bit ABI.  */
4172
4173 void
4174 _bfd_mips_elf_symbol_processing (abfd, asym)
4175      bfd *abfd;
4176      asymbol *asym;
4177 {
4178   elf_symbol_type *elfsym;
4179
4180   elfsym = (elf_symbol_type *) asym;
4181   switch (elfsym->internal_elf_sym.st_shndx)
4182     {
4183     case SHN_MIPS_ACOMMON:
4184       /* This section is used in a dynamically linked executable file.
4185          It is an allocated common section.  The dynamic linker can
4186          either resolve these symbols to something in a shared
4187          library, or it can just leave them here.  For our purposes,
4188          we can consider these symbols to be in a new section.  */
4189       if (mips_elf_acom_section.name == NULL)
4190         {
4191           /* Initialize the acommon section.  */
4192           mips_elf_acom_section.name = ".acommon";
4193           mips_elf_acom_section.flags = SEC_ALLOC;
4194           mips_elf_acom_section.output_section = &mips_elf_acom_section;
4195           mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
4196           mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
4197           mips_elf_acom_symbol.name = ".acommon";
4198           mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
4199           mips_elf_acom_symbol.section = &mips_elf_acom_section;
4200           mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
4201         }
4202       asym->section = &mips_elf_acom_section;
4203       break;
4204
4205     case SHN_COMMON:
4206       /* Common symbols less than the GP size are automatically
4207          treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
4208       if (asym->value > elf_gp_size (abfd)
4209           || IRIX_COMPAT (abfd) == ict_irix6)
4210         break;
4211       /* Fall through.  */
4212     case SHN_MIPS_SCOMMON:
4213       if (mips_elf_scom_section.name == NULL)
4214         {
4215           /* Initialize the small common section.  */
4216           mips_elf_scom_section.name = ".scommon";
4217           mips_elf_scom_section.flags = SEC_IS_COMMON;
4218           mips_elf_scom_section.output_section = &mips_elf_scom_section;
4219           mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
4220           mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
4221           mips_elf_scom_symbol.name = ".scommon";
4222           mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
4223           mips_elf_scom_symbol.section = &mips_elf_scom_section;
4224           mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
4225         }
4226       asym->section = &mips_elf_scom_section;
4227       asym->value = elfsym->internal_elf_sym.st_size;
4228       break;
4229
4230     case SHN_MIPS_SUNDEFINED:
4231       asym->section = bfd_und_section_ptr;
4232       break;
4233
4234 #if 0 /* for SGI_COMPAT */
4235     case SHN_MIPS_TEXT:
4236       asym->section = mips_elf_text_section_ptr;
4237       break;
4238
4239     case SHN_MIPS_DATA:
4240       asym->section = mips_elf_data_section_ptr;
4241       break;
4242 #endif
4243     }
4244 }
4245 \f
4246 /* Work over a section just before writing it out.  This routine is
4247    used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
4248    sections that need the SHF_MIPS_GPREL flag by name; there has to be
4249    a better way.  */
4250
4251 bfd_boolean
4252 _bfd_mips_elf_section_processing (abfd, hdr)
4253      bfd *abfd;
4254      Elf_Internal_Shdr *hdr;
4255 {
4256   if (hdr->sh_type == SHT_MIPS_REGINFO
4257       && hdr->sh_size > 0)
4258     {
4259       bfd_byte buf[4];
4260
4261       BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
4262       BFD_ASSERT (hdr->contents == NULL);
4263
4264       if (bfd_seek (abfd,
4265                     hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
4266                     SEEK_SET) != 0)
4267         return FALSE;
4268       H_PUT_32 (abfd, elf_gp (abfd), buf);
4269       if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
4270         return FALSE;
4271     }
4272
4273   if (hdr->sh_type == SHT_MIPS_OPTIONS
4274       && hdr->bfd_section != NULL
4275       && mips_elf_section_data (hdr->bfd_section) != NULL
4276       && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
4277     {
4278       bfd_byte *contents, *l, *lend;
4279
4280       /* We stored the section contents in the tdata field in the
4281          set_section_contents routine.  We save the section contents
4282          so that we don't have to read them again.
4283          At this point we know that elf_gp is set, so we can look
4284          through the section contents to see if there is an
4285          ODK_REGINFO structure.  */
4286
4287       contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
4288       l = contents;
4289       lend = contents + hdr->sh_size;
4290       while (l + sizeof (Elf_External_Options) <= lend)
4291         {
4292           Elf_Internal_Options intopt;
4293
4294           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4295                                         &intopt);
4296           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4297             {
4298               bfd_byte buf[8];
4299
4300               if (bfd_seek (abfd,
4301                             (hdr->sh_offset
4302                              + (l - contents)
4303                              + sizeof (Elf_External_Options)
4304                              + (sizeof (Elf64_External_RegInfo) - 8)),
4305                              SEEK_SET) != 0)
4306                 return FALSE;
4307               H_PUT_64 (abfd, elf_gp (abfd), buf);
4308               if (bfd_bwrite (buf, (bfd_size_type) 8, abfd) != 8)
4309                 return FALSE;
4310             }
4311           else if (intopt.kind == ODK_REGINFO)
4312             {
4313               bfd_byte buf[4];
4314
4315               if (bfd_seek (abfd,
4316                             (hdr->sh_offset
4317                              + (l - contents)
4318                              + sizeof (Elf_External_Options)
4319                              + (sizeof (Elf32_External_RegInfo) - 4)),
4320                             SEEK_SET) != 0)
4321                 return FALSE;
4322               H_PUT_32 (abfd, elf_gp (abfd), buf);
4323               if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
4324                 return FALSE;
4325             }
4326           l += intopt.size;
4327         }
4328     }
4329
4330   if (hdr->bfd_section != NULL)
4331     {
4332       const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
4333
4334       if (strcmp (name, ".sdata") == 0
4335           || strcmp (name, ".lit8") == 0
4336           || strcmp (name, ".lit4") == 0)
4337         {
4338           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4339           hdr->sh_type = SHT_PROGBITS;
4340         }
4341       else if (strcmp (name, ".sbss") == 0)
4342         {
4343           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4344           hdr->sh_type = SHT_NOBITS;
4345         }
4346       else if (strcmp (name, ".srdata") == 0)
4347         {
4348           hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
4349           hdr->sh_type = SHT_PROGBITS;
4350         }
4351       else if (strcmp (name, ".compact_rel") == 0)
4352         {
4353           hdr->sh_flags = 0;
4354           hdr->sh_type = SHT_PROGBITS;
4355         }
4356       else if (strcmp (name, ".rtproc") == 0)
4357         {
4358           if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
4359             {
4360               unsigned int adjust;
4361
4362               adjust = hdr->sh_size % hdr->sh_addralign;
4363               if (adjust != 0)
4364                 hdr->sh_size += hdr->sh_addralign - adjust;
4365             }
4366         }
4367     }
4368
4369   return TRUE;
4370 }
4371
4372 /* Handle a MIPS specific section when reading an object file.  This
4373    is called when elfcode.h finds a section with an unknown type.
4374    This routine supports both the 32-bit and 64-bit ELF ABI.
4375
4376    FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4377    how to.  */
4378
4379 bfd_boolean
4380 _bfd_mips_elf_section_from_shdr (abfd, hdr, name)
4381      bfd *abfd;
4382      Elf_Internal_Shdr *hdr;
4383      const char *name;
4384 {
4385   flagword flags = 0;
4386
4387   /* There ought to be a place to keep ELF backend specific flags, but
4388      at the moment there isn't one.  We just keep track of the
4389      sections by their name, instead.  Fortunately, the ABI gives
4390      suggested names for all the MIPS specific sections, so we will
4391      probably get away with this.  */
4392   switch (hdr->sh_type)
4393     {
4394     case SHT_MIPS_LIBLIST:
4395       if (strcmp (name, ".liblist") != 0)
4396         return FALSE;
4397       break;
4398     case SHT_MIPS_MSYM:
4399       if (strcmp (name, ".msym") != 0)
4400         return FALSE;
4401       break;
4402     case SHT_MIPS_CONFLICT:
4403       if (strcmp (name, ".conflict") != 0)
4404         return FALSE;
4405       break;
4406     case SHT_MIPS_GPTAB:
4407       if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
4408         return FALSE;
4409       break;
4410     case SHT_MIPS_UCODE:
4411       if (strcmp (name, ".ucode") != 0)
4412         return FALSE;
4413       break;
4414     case SHT_MIPS_DEBUG:
4415       if (strcmp (name, ".mdebug") != 0)
4416         return FALSE;
4417       flags = SEC_DEBUGGING;
4418       break;
4419     case SHT_MIPS_REGINFO:
4420       if (strcmp (name, ".reginfo") != 0
4421           || hdr->sh_size != sizeof (Elf32_External_RegInfo))
4422         return FALSE;
4423       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
4424       break;
4425     case SHT_MIPS_IFACE:
4426       if (strcmp (name, ".MIPS.interfaces") != 0)
4427         return FALSE;
4428       break;
4429     case SHT_MIPS_CONTENT:
4430       if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4431         return FALSE;
4432       break;
4433     case SHT_MIPS_OPTIONS:
4434       if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) != 0)
4435         return FALSE;
4436       break;
4437     case SHT_MIPS_DWARF:
4438       if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0)
4439         return FALSE;
4440       break;
4441     case SHT_MIPS_SYMBOL_LIB:
4442       if (strcmp (name, ".MIPS.symlib") != 0)
4443         return FALSE;
4444       break;
4445     case SHT_MIPS_EVENTS:
4446       if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4447           && strncmp (name, ".MIPS.post_rel",
4448                       sizeof ".MIPS.post_rel" - 1) != 0)
4449         return FALSE;
4450       break;
4451     default:
4452       return FALSE;
4453     }
4454
4455   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
4456     return FALSE;
4457
4458   if (flags)
4459     {
4460       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
4461                                    (bfd_get_section_flags (abfd,
4462                                                            hdr->bfd_section)
4463                                     | flags)))
4464         return FALSE;
4465     }
4466
4467   /* FIXME: We should record sh_info for a .gptab section.  */
4468
4469   /* For a .reginfo section, set the gp value in the tdata information
4470      from the contents of this section.  We need the gp value while
4471      processing relocs, so we just get it now.  The .reginfo section
4472      is not used in the 64-bit MIPS ELF ABI.  */
4473   if (hdr->sh_type == SHT_MIPS_REGINFO)
4474     {
4475       Elf32_External_RegInfo ext;
4476       Elf32_RegInfo s;
4477
4478       if (! bfd_get_section_contents (abfd, hdr->bfd_section, (PTR) &ext,
4479                                       (file_ptr) 0,
4480                                       (bfd_size_type) sizeof ext))
4481         return FALSE;
4482       bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
4483       elf_gp (abfd) = s.ri_gp_value;
4484     }
4485
4486   /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4487      set the gp value based on what we find.  We may see both
4488      SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4489      they should agree.  */
4490   if (hdr->sh_type == SHT_MIPS_OPTIONS)
4491     {
4492       bfd_byte *contents, *l, *lend;
4493
4494       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4495       if (contents == NULL)
4496         return FALSE;
4497       if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
4498                                       (file_ptr) 0, hdr->sh_size))
4499         {
4500           free (contents);
4501           return FALSE;
4502         }
4503       l = contents;
4504       lend = contents + hdr->sh_size;
4505       while (l + sizeof (Elf_External_Options) <= lend)
4506         {
4507           Elf_Internal_Options intopt;
4508
4509           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4510                                         &intopt);
4511           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4512             {
4513               Elf64_Internal_RegInfo intreg;
4514
4515               bfd_mips_elf64_swap_reginfo_in
4516                 (abfd,
4517                  ((Elf64_External_RegInfo *)
4518                   (l + sizeof (Elf_External_Options))),
4519                  &intreg);
4520               elf_gp (abfd) = intreg.ri_gp_value;
4521             }
4522           else if (intopt.kind == ODK_REGINFO)
4523             {
4524               Elf32_RegInfo intreg;
4525
4526               bfd_mips_elf32_swap_reginfo_in
4527                 (abfd,
4528                  ((Elf32_External_RegInfo *)
4529                   (l + sizeof (Elf_External_Options))),
4530                  &intreg);
4531               elf_gp (abfd) = intreg.ri_gp_value;
4532             }
4533           l += intopt.size;
4534         }
4535       free (contents);
4536     }
4537
4538   return TRUE;
4539 }
4540
4541 /* Set the correct type for a MIPS ELF section.  We do this by the
4542    section name, which is a hack, but ought to work.  This routine is
4543    used by both the 32-bit and the 64-bit ABI.  */
4544
4545 bfd_boolean
4546 _bfd_mips_elf_fake_sections (abfd, hdr, sec)
4547      bfd *abfd;
4548      Elf_Internal_Shdr *hdr;
4549      asection *sec;
4550 {
4551   register const char *name;
4552
4553   name = bfd_get_section_name (abfd, sec);
4554
4555   if (strcmp (name, ".liblist") == 0)
4556     {
4557       hdr->sh_type = SHT_MIPS_LIBLIST;
4558       hdr->sh_info = sec->_raw_size / sizeof (Elf32_Lib);
4559       /* The sh_link field is set in final_write_processing.  */
4560     }
4561   else if (strcmp (name, ".conflict") == 0)
4562     hdr->sh_type = SHT_MIPS_CONFLICT;
4563   else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
4564     {
4565       hdr->sh_type = SHT_MIPS_GPTAB;
4566       hdr->sh_entsize = sizeof (Elf32_External_gptab);
4567       /* The sh_info field is set in final_write_processing.  */
4568     }
4569   else if (strcmp (name, ".ucode") == 0)
4570     hdr->sh_type = SHT_MIPS_UCODE;
4571   else if (strcmp (name, ".mdebug") == 0)
4572     {
4573       hdr->sh_type = SHT_MIPS_DEBUG;
4574       /* In a shared object on IRIX 5.3, the .mdebug section has an
4575          entsize of 0.  FIXME: Does this matter?  */
4576       if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
4577         hdr->sh_entsize = 0;
4578       else
4579         hdr->sh_entsize = 1;
4580     }
4581   else if (strcmp (name, ".reginfo") == 0)
4582     {
4583       hdr->sh_type = SHT_MIPS_REGINFO;
4584       /* In a shared object on IRIX 5.3, the .reginfo section has an
4585          entsize of 0x18.  FIXME: Does this matter?  */
4586       if (SGI_COMPAT (abfd))
4587         {
4588           if ((abfd->flags & DYNAMIC) != 0)
4589             hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
4590           else
4591             hdr->sh_entsize = 1;
4592         }
4593       else
4594         hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
4595     }
4596   else if (SGI_COMPAT (abfd)
4597            && (strcmp (name, ".hash") == 0
4598                || strcmp (name, ".dynamic") == 0
4599                || strcmp (name, ".dynstr") == 0))
4600     {
4601       if (SGI_COMPAT (abfd))
4602         hdr->sh_entsize = 0;
4603 #if 0
4604       /* This isn't how the IRIX6 linker behaves.  */
4605       hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
4606 #endif
4607     }
4608   else if (strcmp (name, ".got") == 0
4609            || strcmp (name, ".srdata") == 0
4610            || strcmp (name, ".sdata") == 0
4611            || strcmp (name, ".sbss") == 0
4612            || strcmp (name, ".lit4") == 0
4613            || strcmp (name, ".lit8") == 0)
4614     hdr->sh_flags |= SHF_MIPS_GPREL;
4615   else if (strcmp (name, ".MIPS.interfaces") == 0)
4616     {
4617       hdr->sh_type = SHT_MIPS_IFACE;
4618       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4619     }
4620   else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0)
4621     {
4622       hdr->sh_type = SHT_MIPS_CONTENT;
4623       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4624       /* The sh_info field is set in final_write_processing.  */
4625     }
4626   else if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
4627     {
4628       hdr->sh_type = SHT_MIPS_OPTIONS;
4629       hdr->sh_entsize = 1;
4630       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4631     }
4632   else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0)
4633     hdr->sh_type = SHT_MIPS_DWARF;
4634   else if (strcmp (name, ".MIPS.symlib") == 0)
4635     {
4636       hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
4637       /* The sh_link and sh_info fields are set in
4638          final_write_processing.  */
4639     }
4640   else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4641            || strncmp (name, ".MIPS.post_rel",
4642                        sizeof ".MIPS.post_rel" - 1) == 0)
4643     {
4644       hdr->sh_type = SHT_MIPS_EVENTS;
4645       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4646       /* The sh_link field is set in final_write_processing.  */
4647     }
4648   else if (strcmp (name, ".msym") == 0)
4649     {
4650       hdr->sh_type = SHT_MIPS_MSYM;
4651       hdr->sh_flags |= SHF_ALLOC;
4652       hdr->sh_entsize = 8;
4653     }
4654
4655   /* The generic elf_fake_sections will set up REL_HDR using the default
4656    kind of relocations.  We used to set up a second header for the
4657    non-default kind of relocations here, but only NewABI would use
4658    these, and the IRIX ld doesn't like resulting empty RELA sections.
4659    Thus we create those header only on demand now.  */
4660
4661   return TRUE;
4662 }
4663
4664 /* Given a BFD section, try to locate the corresponding ELF section
4665    index.  This is used by both the 32-bit and the 64-bit ABI.
4666    Actually, it's not clear to me that the 64-bit ABI supports these,
4667    but for non-PIC objects we will certainly want support for at least
4668    the .scommon section.  */
4669
4670 bfd_boolean
4671 _bfd_mips_elf_section_from_bfd_section (abfd, sec, retval)
4672      bfd *abfd ATTRIBUTE_UNUSED;
4673      asection *sec;
4674      int *retval;
4675 {
4676   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
4677     {
4678       *retval = SHN_MIPS_SCOMMON;
4679       return TRUE;
4680     }
4681   if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
4682     {
4683       *retval = SHN_MIPS_ACOMMON;
4684       return TRUE;
4685     }
4686   return FALSE;
4687 }
4688 \f
4689 /* Hook called by the linker routine which adds symbols from an object
4690    file.  We must handle the special MIPS section numbers here.  */
4691
4692 bfd_boolean
4693 _bfd_mips_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4694      bfd *abfd;
4695      struct bfd_link_info *info;
4696      const Elf_Internal_Sym *sym;
4697      const char **namep;
4698      flagword *flagsp ATTRIBUTE_UNUSED;
4699      asection **secp;
4700      bfd_vma *valp;
4701 {
4702   if (SGI_COMPAT (abfd)
4703       && (abfd->flags & DYNAMIC) != 0
4704       && strcmp (*namep, "_rld_new_interface") == 0)
4705     {
4706       /* Skip IRIX5 rld entry name.  */
4707       *namep = NULL;
4708       return TRUE;
4709     }
4710
4711   switch (sym->st_shndx)
4712     {
4713     case SHN_COMMON:
4714       /* Common symbols less than the GP size are automatically
4715          treated as SHN_MIPS_SCOMMON symbols.  */
4716       if (sym->st_size > elf_gp_size (abfd)
4717           || IRIX_COMPAT (abfd) == ict_irix6)
4718         break;
4719       /* Fall through.  */
4720     case SHN_MIPS_SCOMMON:
4721       *secp = bfd_make_section_old_way (abfd, ".scommon");
4722       (*secp)->flags |= SEC_IS_COMMON;
4723       *valp = sym->st_size;
4724       break;
4725
4726     case SHN_MIPS_TEXT:
4727       /* This section is used in a shared object.  */
4728       if (elf_tdata (abfd)->elf_text_section == NULL)
4729         {
4730           asymbol *elf_text_symbol;
4731           asection *elf_text_section;
4732           bfd_size_type amt = sizeof (asection);
4733
4734           elf_text_section = bfd_zalloc (abfd, amt);
4735           if (elf_text_section == NULL)
4736             return FALSE;
4737
4738           amt = sizeof (asymbol);
4739           elf_text_symbol = bfd_zalloc (abfd, amt);
4740           if (elf_text_symbol == NULL)
4741             return FALSE;
4742
4743           /* Initialize the section.  */
4744
4745           elf_tdata (abfd)->elf_text_section = elf_text_section;
4746           elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
4747
4748           elf_text_section->symbol = elf_text_symbol;
4749           elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
4750
4751           elf_text_section->name = ".text";
4752           elf_text_section->flags = SEC_NO_FLAGS;
4753           elf_text_section->output_section = NULL;
4754           elf_text_section->owner = abfd;
4755           elf_text_symbol->name = ".text";
4756           elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4757           elf_text_symbol->section = elf_text_section;
4758         }
4759       /* This code used to do *secp = bfd_und_section_ptr if
4760          info->shared.  I don't know why, and that doesn't make sense,
4761          so I took it out.  */
4762       *secp = elf_tdata (abfd)->elf_text_section;
4763       break;
4764
4765     case SHN_MIPS_ACOMMON:
4766       /* Fall through. XXX Can we treat this as allocated data?  */
4767     case SHN_MIPS_DATA:
4768       /* This section is used in a shared object.  */
4769       if (elf_tdata (abfd)->elf_data_section == NULL)
4770         {
4771           asymbol *elf_data_symbol;
4772           asection *elf_data_section;
4773           bfd_size_type amt = sizeof (asection);
4774
4775           elf_data_section = bfd_zalloc (abfd, amt);
4776           if (elf_data_section == NULL)
4777             return FALSE;
4778
4779           amt = sizeof (asymbol);
4780           elf_data_symbol = bfd_zalloc (abfd, amt);
4781           if (elf_data_symbol == NULL)
4782             return FALSE;
4783
4784           /* Initialize the section.  */
4785
4786           elf_tdata (abfd)->elf_data_section = elf_data_section;
4787           elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
4788
4789           elf_data_section->symbol = elf_data_symbol;
4790           elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
4791
4792           elf_data_section->name = ".data";
4793           elf_data_section->flags = SEC_NO_FLAGS;
4794           elf_data_section->output_section = NULL;
4795           elf_data_section->owner = abfd;
4796           elf_data_symbol->name = ".data";
4797           elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4798           elf_data_symbol->section = elf_data_section;
4799         }
4800       /* This code used to do *secp = bfd_und_section_ptr if
4801          info->shared.  I don't know why, and that doesn't make sense,
4802          so I took it out.  */
4803       *secp = elf_tdata (abfd)->elf_data_section;
4804       break;
4805
4806     case SHN_MIPS_SUNDEFINED:
4807       *secp = bfd_und_section_ptr;
4808       break;
4809     }
4810
4811   if (SGI_COMPAT (abfd)
4812       && ! info->shared
4813       && info->hash->creator == abfd->xvec
4814       && strcmp (*namep, "__rld_obj_head") == 0)
4815     {
4816       struct elf_link_hash_entry *h;
4817       struct bfd_link_hash_entry *bh;
4818
4819       /* Mark __rld_obj_head as dynamic.  */
4820       bh = NULL;
4821       if (! (_bfd_generic_link_add_one_symbol
4822              (info, abfd, *namep, BSF_GLOBAL, *secp,
4823               (bfd_vma) *valp, (const char *) NULL, FALSE,
4824               get_elf_backend_data (abfd)->collect, &bh)))
4825         return FALSE;
4826
4827       h = (struct elf_link_hash_entry *) bh;
4828       h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4829       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4830       h->type = STT_OBJECT;
4831
4832       if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4833         return FALSE;
4834
4835       mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
4836     }
4837
4838   /* If this is a mips16 text symbol, add 1 to the value to make it
4839      odd.  This will cause something like .word SYM to come up with
4840      the right value when it is loaded into the PC.  */
4841   if (sym->st_other == STO_MIPS16)
4842     ++*valp;
4843
4844   return TRUE;
4845 }
4846
4847 /* This hook function is called before the linker writes out a global
4848    symbol.  We mark symbols as small common if appropriate.  This is
4849    also where we undo the increment of the value for a mips16 symbol.  */
4850
4851 bfd_boolean
4852 _bfd_mips_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
4853      bfd *abfd ATTRIBUTE_UNUSED;
4854      struct bfd_link_info *info ATTRIBUTE_UNUSED;
4855      const char *name ATTRIBUTE_UNUSED;
4856      Elf_Internal_Sym *sym;
4857      asection *input_sec;
4858 {
4859   /* If we see a common symbol, which implies a relocatable link, then
4860      if a symbol was small common in an input file, mark it as small
4861      common in the output file.  */
4862   if (sym->st_shndx == SHN_COMMON
4863       && strcmp (input_sec->name, ".scommon") == 0)
4864     sym->st_shndx = SHN_MIPS_SCOMMON;
4865
4866   if (sym->st_other == STO_MIPS16
4867       && (sym->st_value & 1) != 0)
4868     --sym->st_value;
4869
4870   return TRUE;
4871 }
4872 \f
4873 /* Functions for the dynamic linker.  */
4874
4875 /* Create dynamic sections when linking against a dynamic object.  */
4876
4877 bfd_boolean
4878 _bfd_mips_elf_create_dynamic_sections (abfd, info)
4879      bfd *abfd;
4880      struct bfd_link_info *info;
4881 {
4882   struct elf_link_hash_entry *h;
4883   struct bfd_link_hash_entry *bh;
4884   flagword flags;
4885   register asection *s;
4886   const char * const *namep;
4887
4888   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4889            | SEC_LINKER_CREATED | SEC_READONLY);
4890
4891   /* Mips ABI requests the .dynamic section to be read only.  */
4892   s = bfd_get_section_by_name (abfd, ".dynamic");
4893   if (s != NULL)
4894     {
4895       if (! bfd_set_section_flags (abfd, s, flags))
4896         return FALSE;
4897     }
4898
4899   /* We need to create .got section.  */
4900   if (! mips_elf_create_got_section (abfd, info, FALSE))
4901     return FALSE;
4902
4903   if (! mips_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
4904     return FALSE;
4905
4906   /* Create the .msym section on IRIX6.  It is used by the dynamic
4907      linker to speed up dynamic relocations, and to avoid computing
4908      the ELF hash for symbols.  */
4909   if (IRIX_COMPAT (abfd) == ict_irix6
4910       && !mips_elf_create_msym_section (abfd))
4911     return FALSE;
4912
4913   /* Create .stub section.  */
4914   if (bfd_get_section_by_name (abfd,
4915                                MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
4916     {
4917       s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
4918       if (s == NULL
4919           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4920           || ! bfd_set_section_alignment (abfd, s,
4921                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4922         return FALSE;
4923     }
4924
4925   if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
4926       && !info->shared
4927       && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
4928     {
4929       s = bfd_make_section (abfd, ".rld_map");
4930       if (s == NULL
4931           || ! bfd_set_section_flags (abfd, s, flags &~ (flagword) SEC_READONLY)
4932           || ! bfd_set_section_alignment (abfd, s,
4933                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4934         return FALSE;
4935     }
4936
4937   /* On IRIX5, we adjust add some additional symbols and change the
4938      alignments of several sections.  There is no ABI documentation
4939      indicating that this is necessary on IRIX6, nor any evidence that
4940      the linker takes such action.  */
4941   if (IRIX_COMPAT (abfd) == ict_irix5)
4942     {
4943       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
4944         {
4945           bh = NULL;
4946           if (! (_bfd_generic_link_add_one_symbol
4947                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr,
4948                   (bfd_vma) 0, (const char *) NULL, FALSE,
4949                   get_elf_backend_data (abfd)->collect, &bh)))
4950             return FALSE;
4951
4952           h = (struct elf_link_hash_entry *) bh;
4953           h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4954           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4955           h->type = STT_SECTION;
4956
4957           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4958             return FALSE;
4959         }
4960
4961       /* We need to create a .compact_rel section.  */
4962       if (SGI_COMPAT (abfd))
4963         {
4964           if (!mips_elf_create_compact_rel_section (abfd, info))
4965             return FALSE;
4966         }
4967
4968       /* Change alignments of some sections.  */
4969       s = bfd_get_section_by_name (abfd, ".hash");
4970       if (s != NULL)
4971         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4972       s = bfd_get_section_by_name (abfd, ".dynsym");
4973       if (s != NULL)
4974         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4975       s = bfd_get_section_by_name (abfd, ".dynstr");
4976       if (s != NULL)
4977         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4978       s = bfd_get_section_by_name (abfd, ".reginfo");
4979       if (s != NULL)
4980         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4981       s = bfd_get_section_by_name (abfd, ".dynamic");
4982       if (s != NULL)
4983         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4984     }
4985
4986   if (!info->shared)
4987     {
4988       const char *name;
4989
4990       name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4991       bh = NULL;
4992       if (!(_bfd_generic_link_add_one_symbol
4993             (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr,
4994              (bfd_vma) 0, (const char *) NULL, FALSE,
4995              get_elf_backend_data (abfd)->collect, &bh)))
4996         return FALSE;
4997
4998       h = (struct elf_link_hash_entry *) bh;
4999       h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5000       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5001       h->type = STT_SECTION;
5002
5003       if (! bfd_elf32_link_record_dynamic_symbol (info, h))
5004         return FALSE;
5005
5006       if (! mips_elf_hash_table (info)->use_rld_obj_head)
5007         {
5008           /* __rld_map is a four byte word located in the .data section
5009              and is filled in by the rtld to contain a pointer to
5010              the _r_debug structure. Its symbol value will be set in
5011              _bfd_mips_elf_finish_dynamic_symbol.  */
5012           s = bfd_get_section_by_name (abfd, ".rld_map");
5013           BFD_ASSERT (s != NULL);
5014
5015           name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
5016           bh = NULL;
5017           if (!(_bfd_generic_link_add_one_symbol
5018                 (info, abfd, name, BSF_GLOBAL, s,
5019                  (bfd_vma) 0, (const char *) NULL, FALSE,
5020                  get_elf_backend_data (abfd)->collect, &bh)))
5021             return FALSE;
5022
5023           h = (struct elf_link_hash_entry *) bh;
5024           h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5025           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5026           h->type = STT_OBJECT;
5027
5028           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
5029             return FALSE;
5030         }
5031     }
5032
5033   return TRUE;
5034 }
5035 \f
5036 /* Look through the relocs for a section during the first phase, and
5037    allocate space in the global offset table.  */
5038
5039 bfd_boolean
5040 _bfd_mips_elf_check_relocs (abfd, info, sec, relocs)
5041      bfd *abfd;
5042      struct bfd_link_info *info;
5043      asection *sec;
5044      const Elf_Internal_Rela *relocs;
5045 {
5046   const char *name;
5047   bfd *dynobj;
5048   Elf_Internal_Shdr *symtab_hdr;
5049   struct elf_link_hash_entry **sym_hashes;
5050   struct mips_got_info *g;
5051   size_t extsymoff;
5052   const Elf_Internal_Rela *rel;
5053   const Elf_Internal_Rela *rel_end;
5054   asection *sgot;
5055   asection *sreloc;
5056   struct elf_backend_data *bed;
5057
5058   if (info->relocatable)
5059     return TRUE;
5060
5061   dynobj = elf_hash_table (info)->dynobj;
5062   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5063   sym_hashes = elf_sym_hashes (abfd);
5064   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5065
5066   /* Check for the mips16 stub sections.  */
5067
5068   name = bfd_get_section_name (abfd, sec);
5069   if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5070     {
5071       unsigned long r_symndx;
5072
5073       /* Look at the relocation information to figure out which symbol
5074          this is for.  */
5075
5076       r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5077
5078       if (r_symndx < extsymoff
5079           || sym_hashes[r_symndx - extsymoff] == NULL)
5080         {
5081           asection *o;
5082
5083           /* This stub is for a local symbol.  This stub will only be
5084              needed if there is some relocation in this BFD, other
5085              than a 16 bit function call, which refers to this symbol.  */
5086           for (o = abfd->sections; o != NULL; o = o->next)
5087             {
5088               Elf_Internal_Rela *sec_relocs;
5089               const Elf_Internal_Rela *r, *rend;
5090
5091               /* We can ignore stub sections when looking for relocs.  */
5092               if ((o->flags & SEC_RELOC) == 0
5093                   || o->reloc_count == 0
5094                   || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5095                               sizeof FN_STUB - 1) == 0
5096                   || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5097                               sizeof CALL_STUB - 1) == 0
5098                   || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5099                               sizeof CALL_FP_STUB - 1) == 0)
5100                 continue;
5101
5102               sec_relocs
5103                 = _bfd_elf_link_read_relocs (abfd, o, (PTR) NULL,
5104                                              (Elf_Internal_Rela *) NULL,
5105                                              info->keep_memory);
5106               if (sec_relocs == NULL)
5107                 return FALSE;
5108
5109               rend = sec_relocs + o->reloc_count;
5110               for (r = sec_relocs; r < rend; r++)
5111                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
5112                     && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
5113                   break;
5114
5115               if (elf_section_data (o)->relocs != sec_relocs)
5116                 free (sec_relocs);
5117
5118               if (r < rend)
5119                 break;
5120             }
5121
5122           if (o == NULL)
5123             {
5124               /* There is no non-call reloc for this stub, so we do
5125                  not need it.  Since this function is called before
5126                  the linker maps input sections to output sections, we
5127                  can easily discard it by setting the SEC_EXCLUDE
5128                  flag.  */
5129               sec->flags |= SEC_EXCLUDE;
5130               return TRUE;
5131             }
5132
5133           /* Record this stub in an array of local symbol stubs for
5134              this BFD.  */
5135           if (elf_tdata (abfd)->local_stubs == NULL)
5136             {
5137               unsigned long symcount;
5138               asection **n;
5139               bfd_size_type amt;
5140
5141               if (elf_bad_symtab (abfd))
5142                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5143               else
5144                 symcount = symtab_hdr->sh_info;
5145               amt = symcount * sizeof (asection *);
5146               n = (asection **) bfd_zalloc (abfd, amt);
5147               if (n == NULL)
5148                 return FALSE;
5149               elf_tdata (abfd)->local_stubs = n;
5150             }
5151
5152           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5153
5154           /* We don't need to set mips16_stubs_seen in this case.
5155              That flag is used to see whether we need to look through
5156              the global symbol table for stubs.  We don't need to set
5157              it here, because we just have a local stub.  */
5158         }
5159       else
5160         {
5161           struct mips_elf_link_hash_entry *h;
5162
5163           h = ((struct mips_elf_link_hash_entry *)
5164                sym_hashes[r_symndx - extsymoff]);
5165
5166           /* H is the symbol this stub is for.  */
5167
5168           h->fn_stub = sec;
5169           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5170         }
5171     }
5172   else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5173            || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5174     {
5175       unsigned long r_symndx;
5176       struct mips_elf_link_hash_entry *h;
5177       asection **loc;
5178
5179       /* Look at the relocation information to figure out which symbol
5180          this is for.  */
5181
5182       r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5183
5184       if (r_symndx < extsymoff
5185           || sym_hashes[r_symndx - extsymoff] == NULL)
5186         {
5187           /* This stub was actually built for a static symbol defined
5188              in the same file.  We assume that all static symbols in
5189              mips16 code are themselves mips16, so we can simply
5190              discard this stub.  Since this function is called before
5191              the linker maps input sections to output sections, we can
5192              easily discard it by setting the SEC_EXCLUDE flag.  */
5193           sec->flags |= SEC_EXCLUDE;
5194           return TRUE;
5195         }
5196
5197       h = ((struct mips_elf_link_hash_entry *)
5198            sym_hashes[r_symndx - extsymoff]);
5199
5200       /* H is the symbol this stub is for.  */
5201
5202       if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5203         loc = &h->call_fp_stub;
5204       else
5205         loc = &h->call_stub;
5206
5207       /* If we already have an appropriate stub for this function, we
5208          don't need another one, so we can discard this one.  Since
5209          this function is called before the linker maps input sections
5210          to output sections, we can easily discard it by setting the
5211          SEC_EXCLUDE flag.  We can also discard this section if we
5212          happen to already know that this is a mips16 function; it is
5213          not necessary to check this here, as it is checked later, but
5214          it is slightly faster to check now.  */
5215       if (*loc != NULL || h->root.other == STO_MIPS16)
5216         {
5217           sec->flags |= SEC_EXCLUDE;
5218           return TRUE;
5219         }
5220
5221       *loc = sec;
5222       mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5223     }
5224
5225   if (dynobj == NULL)
5226     {
5227       sgot = NULL;
5228       g = NULL;
5229     }
5230   else
5231     {
5232       sgot = mips_elf_got_section (dynobj, FALSE);
5233       if (sgot == NULL)
5234         g = NULL;
5235       else
5236         {
5237           BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
5238           g = mips_elf_section_data (sgot)->u.got_info;
5239           BFD_ASSERT (g != NULL);
5240         }
5241     }
5242
5243   sreloc = NULL;
5244   bed = get_elf_backend_data (abfd);
5245   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5246   for (rel = relocs; rel < rel_end; ++rel)
5247     {
5248       unsigned long r_symndx;
5249       unsigned int r_type;
5250       struct elf_link_hash_entry *h;
5251
5252       r_symndx = ELF_R_SYM (abfd, rel->r_info);
5253       r_type = ELF_R_TYPE (abfd, rel->r_info);
5254
5255       if (r_symndx < extsymoff)
5256         h = NULL;
5257       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5258         {
5259           (*_bfd_error_handler)
5260             (_("%s: Malformed reloc detected for section %s"),
5261              bfd_archive_filename (abfd), name);
5262           bfd_set_error (bfd_error_bad_value);
5263           return FALSE;
5264         }
5265       else
5266         {
5267           h = sym_hashes[r_symndx - extsymoff];
5268
5269           /* This may be an indirect symbol created because of a version.  */
5270           if (h != NULL)
5271             {
5272               while (h->root.type == bfd_link_hash_indirect)
5273                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5274             }
5275         }
5276
5277       /* Some relocs require a global offset table.  */
5278       if (dynobj == NULL || sgot == NULL)
5279         {
5280           switch (r_type)
5281             {
5282             case R_MIPS_GOT16:
5283             case R_MIPS_CALL16:
5284             case R_MIPS_CALL_HI16:
5285             case R_MIPS_CALL_LO16:
5286             case R_MIPS_GOT_HI16:
5287             case R_MIPS_GOT_LO16:
5288             case R_MIPS_GOT_PAGE:
5289             case R_MIPS_GOT_OFST:
5290             case R_MIPS_GOT_DISP:
5291               if (dynobj == NULL)
5292                 elf_hash_table (info)->dynobj = dynobj = abfd;
5293               if (! mips_elf_create_got_section (dynobj, info, FALSE))
5294                 return FALSE;
5295               g = mips_elf_got_info (dynobj, &sgot);
5296               break;
5297
5298             case R_MIPS_32:
5299             case R_MIPS_REL32:
5300             case R_MIPS_64:
5301               if (dynobj == NULL
5302                   && (info->shared || h != NULL)
5303                   && (sec->flags & SEC_ALLOC) != 0)
5304                 elf_hash_table (info)->dynobj = dynobj = abfd;
5305               break;
5306
5307             default:
5308               break;
5309             }
5310         }
5311
5312       if (!h && (r_type == R_MIPS_CALL_LO16
5313                  || r_type == R_MIPS_GOT_LO16
5314                  || r_type == R_MIPS_GOT_DISP))
5315         {
5316           /* We may need a local GOT entry for this relocation.  We
5317              don't count R_MIPS_GOT_PAGE because we can estimate the
5318              maximum number of pages needed by looking at the size of
5319              the segment.  Similar comments apply to R_MIPS_GOT16 and
5320              R_MIPS_CALL16.  We don't count R_MIPS_GOT_HI16, or
5321              R_MIPS_CALL_HI16 because these are always followed by an
5322              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
5323           if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
5324                                                   rel->r_addend, g))
5325             return FALSE;
5326         }
5327
5328       switch (r_type)
5329         {
5330         case R_MIPS_CALL16:
5331           if (h == NULL)
5332             {
5333               (*_bfd_error_handler)
5334                 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5335                  bfd_archive_filename (abfd), (unsigned long) rel->r_offset);
5336               bfd_set_error (bfd_error_bad_value);
5337               return FALSE;
5338             }
5339           /* Fall through.  */
5340
5341         case R_MIPS_CALL_HI16:
5342         case R_MIPS_CALL_LO16:
5343           if (h != NULL)
5344             {
5345               /* This symbol requires a global offset table entry.  */
5346               if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5347                 return FALSE;
5348
5349               /* We need a stub, not a plt entry for the undefined
5350                  function.  But we record it as if it needs plt.  See
5351                  elf_adjust_dynamic_symbol in elflink.h.  */
5352               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
5353               h->type = STT_FUNC;
5354             }
5355           break;
5356
5357         case R_MIPS_GOT_PAGE:
5358           /* If this is a global, overridable symbol, GOT_PAGE will
5359              decay to GOT_DISP, so we'll need a GOT entry for it.  */
5360           if (h == NULL)
5361             break;
5362           else
5363             {
5364               struct mips_elf_link_hash_entry *hmips =
5365                 (struct mips_elf_link_hash_entry *) h;
5366
5367               while (hmips->root.root.type == bfd_link_hash_indirect
5368                      || hmips->root.root.type == bfd_link_hash_warning)
5369                 hmips = (struct mips_elf_link_hash_entry *)
5370                   hmips->root.root.u.i.link;
5371
5372               if ((hmips->root.root.type == bfd_link_hash_defined
5373                    || hmips->root.root.type == bfd_link_hash_defweak)
5374                   && hmips->root.root.u.def.section
5375                   && ! (info->shared && ! info->symbolic
5376                         && ! (hmips->root.elf_link_hash_flags
5377                               & ELF_LINK_FORCED_LOCAL))
5378                   /* If we've encountered any other relocation
5379                      referencing the symbol, we'll have marked it as
5380                      dynamic, and, even though we might be able to get
5381                      rid of the GOT entry should we know for sure all
5382                      previous relocations were GOT_PAGE ones, at this
5383                      point we can't tell, so just keep using the
5384                      symbol as dynamic.  This is very important in the
5385                      multi-got case, since we don't decide whether to
5386                      decay GOT_PAGE to GOT_DISP on a per-GOT basis: if
5387                      the symbol is dynamic, we'll need a GOT entry for
5388                      every GOT in which the symbol is referenced with
5389                      a GOT_PAGE relocation.  */
5390                   && hmips->root.dynindx == -1)
5391                 break;
5392             }
5393           /* Fall through.  */
5394
5395         case R_MIPS_GOT16:
5396         case R_MIPS_GOT_HI16:
5397         case R_MIPS_GOT_LO16:
5398         case R_MIPS_GOT_DISP:
5399           /* This symbol requires a global offset table entry.  */
5400           if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g))
5401             return FALSE;
5402           break;
5403
5404         case R_MIPS_32:
5405         case R_MIPS_REL32:
5406         case R_MIPS_64:
5407           if ((info->shared || h != NULL)
5408               && (sec->flags & SEC_ALLOC) != 0)
5409             {
5410               if (sreloc == NULL)
5411                 {
5412                   sreloc = mips_elf_rel_dyn_section (dynobj, TRUE);
5413                   if (sreloc == NULL)
5414                     return FALSE;
5415                 }
5416 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5417               if (info->shared)
5418                 {
5419                   /* When creating a shared object, we must copy these
5420                      reloc types into the output file as R_MIPS_REL32
5421                      relocs.  We make room for this reloc in the
5422                      .rel.dyn reloc section.  */
5423                   mips_elf_allocate_dynamic_relocations (dynobj, 1);
5424                   if ((sec->flags & MIPS_READONLY_SECTION)
5425                       == MIPS_READONLY_SECTION)
5426                     /* We tell the dynamic linker that there are
5427                        relocations against the text segment.  */
5428                     info->flags |= DF_TEXTREL;
5429                 }
5430               else
5431                 {
5432                   struct mips_elf_link_hash_entry *hmips;
5433
5434                   /* We only need to copy this reloc if the symbol is
5435                      defined in a dynamic object.  */
5436                   hmips = (struct mips_elf_link_hash_entry *) h;
5437                   ++hmips->possibly_dynamic_relocs;
5438                   if ((sec->flags & MIPS_READONLY_SECTION)
5439                       == MIPS_READONLY_SECTION)
5440                     /* We need it to tell the dynamic linker if there
5441                        are relocations against the text segment.  */
5442                     hmips->readonly_reloc = TRUE;
5443                 }
5444
5445               /* Even though we don't directly need a GOT entry for
5446                  this symbol, a symbol must have a dynamic symbol
5447                  table index greater that DT_MIPS_GOTSYM if there are
5448                  dynamic relocations against it.  */
5449               if (h != NULL)
5450                 {
5451                   if (dynobj == NULL)
5452                     elf_hash_table (info)->dynobj = dynobj = abfd;
5453                   if (! mips_elf_create_got_section (dynobj, info, TRUE))
5454                     return FALSE;
5455                   g = mips_elf_got_info (dynobj, &sgot);
5456                   if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5457                     return FALSE;
5458                 }
5459             }
5460
5461           if (SGI_COMPAT (abfd))
5462             mips_elf_hash_table (info)->compact_rel_size +=
5463               sizeof (Elf32_External_crinfo);
5464           break;
5465
5466         case R_MIPS_26:
5467         case R_MIPS_GPREL16:
5468         case R_MIPS_LITERAL:
5469         case R_MIPS_GPREL32:
5470           if (SGI_COMPAT (abfd))
5471             mips_elf_hash_table (info)->compact_rel_size +=
5472               sizeof (Elf32_External_crinfo);
5473           break;
5474
5475           /* This relocation describes the C++ object vtable hierarchy.
5476              Reconstruct it for later use during GC.  */
5477         case R_MIPS_GNU_VTINHERIT:
5478           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5479             return FALSE;
5480           break;
5481
5482           /* This relocation describes which C++ vtable entries are actually
5483              used.  Record for later use during GC.  */
5484         case R_MIPS_GNU_VTENTRY:
5485           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
5486             return FALSE;
5487           break;
5488
5489         default:
5490           break;
5491         }
5492
5493       /* We must not create a stub for a symbol that has relocations
5494          related to taking the function's address.  */
5495       switch (r_type)
5496         {
5497         default:
5498           if (h != NULL)
5499             {
5500               struct mips_elf_link_hash_entry *mh;
5501
5502               mh = (struct mips_elf_link_hash_entry *) h;
5503               mh->no_fn_stub = TRUE;
5504             }
5505           break;
5506         case R_MIPS_CALL16:
5507         case R_MIPS_CALL_HI16:
5508         case R_MIPS_CALL_LO16:
5509         case R_MIPS_JALR:
5510           break;
5511         }
5512
5513       /* If this reloc is not a 16 bit call, and it has a global
5514          symbol, then we will need the fn_stub if there is one.
5515          References from a stub section do not count.  */
5516       if (h != NULL
5517           && r_type != R_MIPS16_26
5518           && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
5519                       sizeof FN_STUB - 1) != 0
5520           && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
5521                       sizeof CALL_STUB - 1) != 0
5522           && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
5523                       sizeof CALL_FP_STUB - 1) != 0)
5524         {
5525           struct mips_elf_link_hash_entry *mh;
5526
5527           mh = (struct mips_elf_link_hash_entry *) h;
5528           mh->need_fn_stub = TRUE;
5529         }
5530     }
5531
5532   return TRUE;
5533 }
5534 \f
5535 bfd_boolean
5536 _bfd_mips_relax_section (abfd, sec, link_info, again)
5537      bfd *abfd;
5538      asection *sec;
5539      struct bfd_link_info *link_info;
5540      bfd_boolean *again;
5541 {
5542   Elf_Internal_Rela *internal_relocs;
5543   Elf_Internal_Rela *irel, *irelend;
5544   Elf_Internal_Shdr *symtab_hdr;
5545   bfd_byte *contents = NULL;
5546   bfd_byte *free_contents = NULL;
5547   size_t extsymoff;
5548   bfd_boolean changed_contents = FALSE;
5549   bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
5550   Elf_Internal_Sym *isymbuf = NULL;
5551
5552   /* We are not currently changing any sizes, so only one pass.  */
5553   *again = FALSE;
5554
5555   if (link_info->relocatable)
5556     return TRUE;
5557
5558   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, (PTR) NULL,
5559                                                (Elf_Internal_Rela *) NULL,
5560                                                link_info->keep_memory);
5561   if (internal_relocs == NULL)
5562     return TRUE;
5563
5564   irelend = internal_relocs + sec->reloc_count
5565     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
5566   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5567   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5568
5569   for (irel = internal_relocs; irel < irelend; irel++)
5570     {
5571       bfd_vma symval;
5572       bfd_signed_vma sym_offset;
5573       unsigned int r_type;
5574       unsigned long r_symndx;
5575       asection *sym_sec;
5576       unsigned long instruction;
5577
5578       /* Turn jalr into bgezal, and jr into beq, if they're marked
5579          with a JALR relocation, that indicate where they jump to.
5580          This saves some pipeline bubbles.  */
5581       r_type = ELF_R_TYPE (abfd, irel->r_info);
5582       if (r_type != R_MIPS_JALR)
5583         continue;
5584
5585       r_symndx = ELF_R_SYM (abfd, irel->r_info);
5586       /* Compute the address of the jump target.  */
5587       if (r_symndx >= extsymoff)
5588         {
5589           struct mips_elf_link_hash_entry *h
5590             = ((struct mips_elf_link_hash_entry *)
5591                elf_sym_hashes (abfd) [r_symndx - extsymoff]);
5592
5593           while (h->root.root.type == bfd_link_hash_indirect
5594                  || h->root.root.type == bfd_link_hash_warning)
5595             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5596
5597           /* If a symbol is undefined, or if it may be overridden,
5598              skip it.  */
5599           if (! ((h->root.root.type == bfd_link_hash_defined
5600                   || h->root.root.type == bfd_link_hash_defweak)
5601                  && h->root.root.u.def.section)
5602               || (link_info->shared && ! link_info->symbolic
5603                   && ! (h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)))
5604             continue;
5605
5606           sym_sec = h->root.root.u.def.section;
5607           if (sym_sec->output_section)
5608             symval = (h->root.root.u.def.value
5609                       + sym_sec->output_section->vma
5610                       + sym_sec->output_offset);
5611           else
5612             symval = h->root.root.u.def.value;
5613         }
5614       else
5615         {
5616           Elf_Internal_Sym *isym;
5617
5618           /* Read this BFD's symbols if we haven't done so already.  */
5619           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
5620             {
5621               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5622               if (isymbuf == NULL)
5623                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5624                                                 symtab_hdr->sh_info, 0,
5625                                                 NULL, NULL, NULL);
5626               if (isymbuf == NULL)
5627                 goto relax_return;
5628             }
5629
5630           isym = isymbuf + r_symndx;
5631           if (isym->st_shndx == SHN_UNDEF)
5632             continue;
5633           else if (isym->st_shndx == SHN_ABS)
5634             sym_sec = bfd_abs_section_ptr;
5635           else if (isym->st_shndx == SHN_COMMON)
5636             sym_sec = bfd_com_section_ptr;
5637           else
5638             sym_sec
5639               = bfd_section_from_elf_index (abfd, isym->st_shndx);
5640           symval = isym->st_value
5641             + sym_sec->output_section->vma
5642             + sym_sec->output_offset;
5643         }
5644
5645       /* Compute branch offset, from delay slot of the jump to the
5646          branch target.  */
5647       sym_offset = (symval + irel->r_addend)
5648         - (sec_start + irel->r_offset + 4);
5649
5650       /* Branch offset must be properly aligned.  */
5651       if ((sym_offset & 3) != 0)
5652         continue;
5653
5654       sym_offset >>= 2;
5655
5656       /* Check that it's in range.  */
5657       if (sym_offset < -0x8000 || sym_offset >= 0x8000)
5658         continue;
5659
5660       /* Get the section contents if we haven't done so already.  */
5661       if (contents == NULL)
5662         {
5663           /* Get cached copy if it exists.  */
5664           if (elf_section_data (sec)->this_hdr.contents != NULL)
5665             contents = elf_section_data (sec)->this_hdr.contents;
5666           else
5667             {
5668               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
5669               if (contents == NULL)
5670                 goto relax_return;
5671
5672               free_contents = contents;
5673               if (! bfd_get_section_contents (abfd, sec, contents,
5674                                               (file_ptr) 0, sec->_raw_size))
5675                 goto relax_return;
5676             }
5677         }
5678
5679       instruction = bfd_get_32 (abfd, contents + irel->r_offset);
5680
5681       /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
5682       if ((instruction & 0xfc1fffff) == 0x0000f809)
5683         instruction = 0x04110000;
5684       /* If it was jr <reg>, turn it into b <target>.  */
5685       else if ((instruction & 0xfc1fffff) == 0x00000008)
5686         instruction = 0x10000000;
5687       else
5688         continue;
5689
5690       instruction |= (sym_offset & 0xffff);
5691       bfd_put_32 (abfd, instruction, contents + irel->r_offset);
5692       changed_contents = TRUE;
5693     }
5694
5695   if (contents != NULL
5696       && elf_section_data (sec)->this_hdr.contents != contents)
5697     {
5698       if (!changed_contents && !link_info->keep_memory)
5699         free (contents);
5700       else
5701         {
5702           /* Cache the section contents for elf_link_input_bfd.  */
5703           elf_section_data (sec)->this_hdr.contents = contents;
5704         }
5705     }
5706   return TRUE;
5707
5708  relax_return:
5709   if (free_contents != NULL)
5710     free (free_contents);
5711   return FALSE;
5712 }
5713 \f
5714 /* Adjust a symbol defined by a dynamic object and referenced by a
5715    regular object.  The current definition is in some section of the
5716    dynamic object, but we're not including those sections.  We have to
5717    change the definition to something the rest of the link can
5718    understand.  */
5719
5720 bfd_boolean
5721 _bfd_mips_elf_adjust_dynamic_symbol (info, h)
5722      struct bfd_link_info *info;
5723      struct elf_link_hash_entry *h;
5724 {
5725   bfd *dynobj;
5726   struct mips_elf_link_hash_entry *hmips;
5727   asection *s;
5728
5729   dynobj = elf_hash_table (info)->dynobj;
5730
5731   /* Make sure we know what is going on here.  */
5732   BFD_ASSERT (dynobj != NULL
5733               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
5734                   || h->weakdef != NULL
5735                   || ((h->elf_link_hash_flags
5736                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5737                       && (h->elf_link_hash_flags
5738                           & ELF_LINK_HASH_REF_REGULAR) != 0
5739                       && (h->elf_link_hash_flags
5740                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
5741
5742   /* If this symbol is defined in a dynamic object, we need to copy
5743      any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5744      file.  */
5745   hmips = (struct mips_elf_link_hash_entry *) h;
5746   if (! info->relocatable
5747       && hmips->possibly_dynamic_relocs != 0
5748       && (h->root.type == bfd_link_hash_defweak
5749           || (h->elf_link_hash_flags
5750               & ELF_LINK_HASH_DEF_REGULAR) == 0))
5751     {
5752       mips_elf_allocate_dynamic_relocations (dynobj,
5753                                              hmips->possibly_dynamic_relocs);
5754       if (hmips->readonly_reloc)
5755         /* We tell the dynamic linker that there are relocations
5756            against the text segment.  */
5757         info->flags |= DF_TEXTREL;
5758     }
5759
5760   /* For a function, create a stub, if allowed.  */
5761   if (! hmips->no_fn_stub
5762       && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
5763     {
5764       if (! elf_hash_table (info)->dynamic_sections_created)
5765         return TRUE;
5766
5767       /* If this symbol is not defined in a regular file, then set
5768          the symbol to the stub location.  This is required to make
5769          function pointers compare as equal between the normal
5770          executable and the shared library.  */
5771       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
5772         {
5773           /* We need .stub section.  */
5774           s = bfd_get_section_by_name (dynobj,
5775                                        MIPS_ELF_STUB_SECTION_NAME (dynobj));
5776           BFD_ASSERT (s != NULL);
5777
5778           h->root.u.def.section = s;
5779           h->root.u.def.value = s->_raw_size;
5780
5781           /* XXX Write this stub address somewhere.  */
5782           h->plt.offset = s->_raw_size;
5783
5784           /* Make room for this stub code.  */
5785           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
5786
5787           /* The last half word of the stub will be filled with the index
5788              of this symbol in .dynsym section.  */
5789           return TRUE;
5790         }
5791     }
5792   else if ((h->type == STT_FUNC)
5793            && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
5794     {
5795       /* This will set the entry for this symbol in the GOT to 0, and
5796          the dynamic linker will take care of this.  */
5797       h->root.u.def.value = 0;
5798       return TRUE;
5799     }
5800
5801   /* If this is a weak symbol, and there is a real definition, the
5802      processor independent code will have arranged for us to see the
5803      real definition first, and we can just use the same value.  */
5804   if (h->weakdef != NULL)
5805     {
5806       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
5807                   || h->weakdef->root.type == bfd_link_hash_defweak);
5808       h->root.u.def.section = h->weakdef->root.u.def.section;
5809       h->root.u.def.value = h->weakdef->root.u.def.value;
5810       return TRUE;
5811     }
5812
5813   /* This is a reference to a symbol defined by a dynamic object which
5814      is not a function.  */
5815
5816   return TRUE;
5817 }
5818 \f
5819 /* This function is called after all the input files have been read,
5820    and the input sections have been assigned to output sections.  We
5821    check for any mips16 stub sections that we can discard.  */
5822
5823 bfd_boolean
5824 _bfd_mips_elf_always_size_sections (output_bfd, info)
5825      bfd *output_bfd;
5826      struct bfd_link_info *info;
5827 {
5828   asection *ri;
5829
5830   bfd *dynobj;
5831   asection *s;
5832   struct mips_got_info *g;
5833   int i;
5834   bfd_size_type loadable_size = 0;
5835   bfd_size_type local_gotno;
5836   bfd *sub;
5837
5838   /* The .reginfo section has a fixed size.  */
5839   ri = bfd_get_section_by_name (output_bfd, ".reginfo");
5840   if (ri != NULL)
5841     bfd_set_section_size (output_bfd, ri,
5842                           (bfd_size_type) sizeof (Elf32_External_RegInfo));
5843
5844   if (! (info->relocatable
5845          || ! mips_elf_hash_table (info)->mips16_stubs_seen))
5846     mips_elf_link_hash_traverse (mips_elf_hash_table (info),
5847                                  mips_elf_check_mips16_stubs,
5848                                  (PTR) NULL);
5849
5850   dynobj = elf_hash_table (info)->dynobj;
5851   if (dynobj == NULL)
5852     /* Relocatable links don't have it.  */
5853     return TRUE;
5854
5855   g = mips_elf_got_info (dynobj, &s);
5856   if (s == NULL)
5857     return TRUE;
5858
5859   /* Calculate the total loadable size of the output.  That
5860      will give us the maximum number of GOT_PAGE entries
5861      required.  */
5862   for (sub = info->input_bfds; sub; sub = sub->link_next)
5863     {
5864       asection *subsection;
5865
5866       for (subsection = sub->sections;
5867            subsection;
5868            subsection = subsection->next)
5869         {
5870           if ((subsection->flags & SEC_ALLOC) == 0)
5871             continue;
5872           loadable_size += ((subsection->_raw_size + 0xf)
5873                             &~ (bfd_size_type) 0xf);
5874         }
5875     }
5876
5877   /* There has to be a global GOT entry for every symbol with
5878      a dynamic symbol table index of DT_MIPS_GOTSYM or
5879      higher.  Therefore, it make sense to put those symbols
5880      that need GOT entries at the end of the symbol table.  We
5881      do that here.  */
5882   if (! mips_elf_sort_hash_table (info, 1))
5883     return FALSE;
5884
5885   if (g->global_gotsym != NULL)
5886     i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
5887   else
5888     /* If there are no global symbols, or none requiring
5889        relocations, then GLOBAL_GOTSYM will be NULL.  */
5890     i = 0;
5891
5892   /* In the worst case, we'll get one stub per dynamic symbol, plus
5893      one to account for the dummy entry at the end required by IRIX
5894      rld.  */
5895   loadable_size += MIPS_FUNCTION_STUB_SIZE * (i + 1);
5896
5897   /* Assume there are two loadable segments consisting of
5898      contiguous sections.  Is 5 enough?  */
5899   local_gotno = (loadable_size >> 16) + 5;
5900
5901   g->local_gotno += local_gotno;
5902   s->_raw_size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
5903
5904   g->global_gotno = i;
5905   s->_raw_size += i * MIPS_ELF_GOT_SIZE (output_bfd);
5906
5907   if (s->_raw_size > MIPS_ELF_GOT_MAX_SIZE (output_bfd)
5908       && ! mips_elf_multi_got (output_bfd, info, g, s, local_gotno))
5909     return FALSE;
5910
5911   return TRUE;
5912 }
5913
5914 /* Set the sizes of the dynamic sections.  */
5915
5916 bfd_boolean
5917 _bfd_mips_elf_size_dynamic_sections (output_bfd, info)
5918      bfd *output_bfd;
5919      struct bfd_link_info *info;
5920 {
5921   bfd *dynobj;
5922   asection *s;
5923   bfd_boolean reltext;
5924
5925   dynobj = elf_hash_table (info)->dynobj;
5926   BFD_ASSERT (dynobj != NULL);
5927
5928   if (elf_hash_table (info)->dynamic_sections_created)
5929     {
5930       /* Set the contents of the .interp section to the interpreter.  */
5931       if (! info->shared)
5932         {
5933           s = bfd_get_section_by_name (dynobj, ".interp");
5934           BFD_ASSERT (s != NULL);
5935           s->_raw_size
5936             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
5937           s->contents
5938             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
5939         }
5940     }
5941
5942   /* The check_relocs and adjust_dynamic_symbol entry points have
5943      determined the sizes of the various dynamic sections.  Allocate
5944      memory for them.  */
5945   reltext = FALSE;
5946   for (s = dynobj->sections; s != NULL; s = s->next)
5947     {
5948       const char *name;
5949       bfd_boolean strip;
5950
5951       /* It's OK to base decisions on the section name, because none
5952          of the dynobj section names depend upon the input files.  */
5953       name = bfd_get_section_name (dynobj, s);
5954
5955       if ((s->flags & SEC_LINKER_CREATED) == 0)
5956         continue;
5957
5958       strip = FALSE;
5959
5960       if (strncmp (name, ".rel", 4) == 0)
5961         {
5962           if (s->_raw_size == 0)
5963             {
5964               /* We only strip the section if the output section name
5965                  has the same name.  Otherwise, there might be several
5966                  input sections for this output section.  FIXME: This
5967                  code is probably not needed these days anyhow, since
5968                  the linker now does not create empty output sections.  */
5969               if (s->output_section != NULL
5970                   && strcmp (name,
5971                              bfd_get_section_name (s->output_section->owner,
5972                                                    s->output_section)) == 0)
5973                 strip = TRUE;
5974             }
5975           else
5976             {
5977               const char *outname;
5978               asection *target;
5979
5980               /* If this relocation section applies to a read only
5981                  section, then we probably need a DT_TEXTREL entry.
5982                  If the relocation section is .rel.dyn, we always
5983                  assert a DT_TEXTREL entry rather than testing whether
5984                  there exists a relocation to a read only section or
5985                  not.  */
5986               outname = bfd_get_section_name (output_bfd,
5987                                               s->output_section);
5988               target = bfd_get_section_by_name (output_bfd, outname + 4);
5989               if ((target != NULL
5990                    && (target->flags & SEC_READONLY) != 0
5991                    && (target->flags & SEC_ALLOC) != 0)
5992                   || strcmp (outname, ".rel.dyn") == 0)
5993                 reltext = TRUE;
5994
5995               /* We use the reloc_count field as a counter if we need
5996                  to copy relocs into the output file.  */
5997               if (strcmp (name, ".rel.dyn") != 0)
5998                 s->reloc_count = 0;
5999
6000               /* If combreloc is enabled, elf_link_sort_relocs() will
6001                  sort relocations, but in a different way than we do,
6002                  and before we're done creating relocations.  Also, it
6003                  will move them around between input sections'
6004                  relocation's contents, so our sorting would be
6005                  broken, so don't let it run.  */
6006               info->combreloc = 0;
6007             }
6008         }
6009       else if (strncmp (name, ".got", 4) == 0)
6010         {
6011           /* _bfd_mips_elf_always_size_sections() has already done
6012              most of the work, but some symbols may have been mapped
6013              to versions that we must now resolve in the got_entries
6014              hash tables.  */
6015           struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
6016           struct mips_got_info *g = gg;
6017           struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
6018           unsigned int needed_relocs = 0;
6019
6020           if (gg->next)
6021             {
6022               set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
6023               set_got_offset_arg.info = info;
6024
6025               mips_elf_resolve_final_got_entries (gg);
6026               for (g = gg->next; g && g->next != gg; g = g->next)
6027                 {
6028                   unsigned int save_assign;
6029
6030                   mips_elf_resolve_final_got_entries (g);
6031
6032                   /* Assign offsets to global GOT entries.  */
6033                   save_assign = g->assigned_gotno;
6034                   g->assigned_gotno = g->local_gotno;
6035                   set_got_offset_arg.g = g;
6036                   set_got_offset_arg.needed_relocs = 0;
6037                   htab_traverse (g->got_entries,
6038                                  mips_elf_set_global_got_offset,
6039                                  &set_got_offset_arg);
6040                   needed_relocs += set_got_offset_arg.needed_relocs;
6041                   BFD_ASSERT (g->assigned_gotno - g->local_gotno
6042                               <= g->global_gotno);
6043
6044                   g->assigned_gotno = save_assign;
6045                   if (info->shared)
6046                     {
6047                       needed_relocs += g->local_gotno - g->assigned_gotno;
6048                       BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
6049                                   + g->next->global_gotno
6050                                   + MIPS_RESERVED_GOTNO);
6051                     }
6052                 }
6053
6054               if (needed_relocs)
6055                 mips_elf_allocate_dynamic_relocations (dynobj, needed_relocs);
6056             }
6057         }
6058       else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
6059         {
6060           /* IRIX rld assumes that the function stub isn't at the end
6061              of .text section. So put a dummy. XXX  */
6062           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
6063         }
6064       else if (! info->shared
6065                && ! mips_elf_hash_table (info)->use_rld_obj_head
6066                && strncmp (name, ".rld_map", 8) == 0)
6067         {
6068           /* We add a room for __rld_map. It will be filled in by the
6069              rtld to contain a pointer to the _r_debug structure.  */
6070           s->_raw_size += 4;
6071         }
6072       else if (SGI_COMPAT (output_bfd)
6073                && strncmp (name, ".compact_rel", 12) == 0)
6074         s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
6075       else if (strcmp (name, ".msym") == 0)
6076         s->_raw_size = (sizeof (Elf32_External_Msym)
6077                         * (elf_hash_table (info)->dynsymcount
6078                            + bfd_count_sections (output_bfd)));
6079       else if (strncmp (name, ".init", 5) != 0)
6080         {
6081           /* It's not one of our sections, so don't allocate space.  */
6082           continue;
6083         }
6084
6085       if (strip)
6086         {
6087           _bfd_strip_section_from_output (info, s);
6088           continue;
6089         }
6090
6091       /* Allocate memory for the section contents.  */
6092       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
6093       if (s->contents == NULL && s->_raw_size != 0)
6094         {
6095           bfd_set_error (bfd_error_no_memory);
6096           return FALSE;
6097         }
6098     }
6099
6100   if (elf_hash_table (info)->dynamic_sections_created)
6101     {
6102       /* Add some entries to the .dynamic section.  We fill in the
6103          values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6104          must add the entries now so that we get the correct size for
6105          the .dynamic section.  The DT_DEBUG entry is filled in by the
6106          dynamic linker and used by the debugger.  */
6107       if (! info->shared)
6108         {
6109           /* SGI object has the equivalence of DT_DEBUG in the
6110              DT_MIPS_RLD_MAP entry.  */
6111           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
6112             return FALSE;
6113           if (!SGI_COMPAT (output_bfd))
6114             {
6115               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6116                 return FALSE;
6117             }
6118         }
6119       else
6120         {
6121           /* Shared libraries on traditional mips have DT_DEBUG.  */
6122           if (!SGI_COMPAT (output_bfd))
6123             {
6124               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6125                 return FALSE;
6126             }
6127         }
6128
6129       if (reltext && SGI_COMPAT (output_bfd))
6130         info->flags |= DF_TEXTREL;
6131
6132       if ((info->flags & DF_TEXTREL) != 0)
6133         {
6134           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
6135             return FALSE;
6136         }
6137
6138       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
6139         return FALSE;
6140
6141       if (mips_elf_rel_dyn_section (dynobj, FALSE))
6142         {
6143           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
6144             return FALSE;
6145
6146           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
6147             return FALSE;
6148
6149           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
6150             return FALSE;
6151         }
6152
6153       if (SGI_COMPAT (output_bfd))
6154         {
6155           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICTNO, 0))
6156             return FALSE;
6157         }
6158
6159       if (SGI_COMPAT (output_bfd))
6160         {
6161           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLISTNO, 0))
6162             return FALSE;
6163         }
6164
6165       if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
6166         {
6167           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICT, 0))
6168             return FALSE;
6169
6170           s = bfd_get_section_by_name (dynobj, ".liblist");
6171           BFD_ASSERT (s != NULL);
6172
6173           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLIST, 0))
6174             return FALSE;
6175         }
6176
6177       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
6178         return FALSE;
6179
6180       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
6181         return FALSE;
6182
6183 #if 0
6184       /* Time stamps in executable files are a bad idea.  */
6185       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
6186         return FALSE;
6187 #endif
6188
6189 #if 0 /* FIXME  */
6190       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
6191         return FALSE;
6192 #endif
6193
6194 #if 0 /* FIXME  */
6195       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
6196         return FALSE;
6197 #endif
6198
6199       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
6200         return FALSE;
6201
6202       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
6203         return FALSE;
6204
6205       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
6206         return FALSE;
6207
6208       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
6209         return FALSE;
6210
6211       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
6212         return FALSE;
6213
6214       if (IRIX_COMPAT (dynobj) == ict_irix5
6215           && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
6216         return FALSE;
6217
6218       if (IRIX_COMPAT (dynobj) == ict_irix6
6219           && (bfd_get_section_by_name
6220               (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
6221           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
6222         return FALSE;
6223
6224       if (bfd_get_section_by_name (dynobj, ".msym")
6225           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_MSYM, 0))
6226         return FALSE;
6227     }
6228
6229   return TRUE;
6230 }
6231 \f
6232 /* Relocate a MIPS ELF section.  */
6233
6234 bfd_boolean
6235 _bfd_mips_elf_relocate_section (output_bfd, info, input_bfd, input_section,
6236                                 contents, relocs, local_syms, local_sections)
6237      bfd *output_bfd;
6238      struct bfd_link_info *info;
6239      bfd *input_bfd;
6240      asection *input_section;
6241      bfd_byte *contents;
6242      Elf_Internal_Rela *relocs;
6243      Elf_Internal_Sym *local_syms;
6244      asection **local_sections;
6245 {
6246   Elf_Internal_Rela *rel;
6247   const Elf_Internal_Rela *relend;
6248   bfd_vma addend = 0;
6249   bfd_boolean use_saved_addend_p = FALSE;
6250   struct elf_backend_data *bed;
6251
6252   bed = get_elf_backend_data (output_bfd);
6253   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6254   for (rel = relocs; rel < relend; ++rel)
6255     {
6256       const char *name;
6257       bfd_vma value;
6258       reloc_howto_type *howto;
6259       bfd_boolean require_jalx;
6260       /* TRUE if the relocation is a RELA relocation, rather than a
6261          REL relocation.  */
6262       bfd_boolean rela_relocation_p = TRUE;
6263       unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6264       const char * msg = (const char *) NULL;
6265
6266       /* Find the relocation howto for this relocation.  */
6267       if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
6268         {
6269           /* Some 32-bit code uses R_MIPS_64.  In particular, people use
6270              64-bit code, but make sure all their addresses are in the
6271              lowermost or uppermost 32-bit section of the 64-bit address
6272              space.  Thus, when they use an R_MIPS_64 they mean what is
6273              usually meant by R_MIPS_32, with the exception that the
6274              stored value is sign-extended to 64 bits.  */
6275           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
6276
6277           /* On big-endian systems, we need to lie about the position
6278              of the reloc.  */
6279           if (bfd_big_endian (input_bfd))
6280             rel->r_offset += 4;
6281         }
6282       else
6283         /* NewABI defaults to RELA relocations.  */
6284         howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
6285                                          NEWABI_P (input_bfd)
6286                                          && (MIPS_RELOC_RELA_P
6287                                              (input_bfd, input_section,
6288                                               rel - relocs)));
6289
6290       if (!use_saved_addend_p)
6291         {
6292           Elf_Internal_Shdr *rel_hdr;
6293
6294           /* If these relocations were originally of the REL variety,
6295              we must pull the addend out of the field that will be
6296              relocated.  Otherwise, we simply use the contents of the
6297              RELA relocation.  To determine which flavor or relocation
6298              this is, we depend on the fact that the INPUT_SECTION's
6299              REL_HDR is read before its REL_HDR2.  */
6300           rel_hdr = &elf_section_data (input_section)->rel_hdr;
6301           if ((size_t) (rel - relocs)
6302               >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6303             rel_hdr = elf_section_data (input_section)->rel_hdr2;
6304           if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6305             {
6306               /* Note that this is a REL relocation.  */
6307               rela_relocation_p = FALSE;
6308
6309               /* Get the addend, which is stored in the input file.  */
6310               addend = mips_elf_obtain_contents (howto, rel, input_bfd,
6311                                                  contents);
6312               addend &= howto->src_mask;
6313               addend <<= howto->rightshift;
6314
6315               /* For some kinds of relocations, the ADDEND is a
6316                  combination of the addend stored in two different
6317                  relocations.   */
6318               if (r_type == R_MIPS_HI16
6319                   || r_type == R_MIPS_GNU_REL_HI16
6320                   || (r_type == R_MIPS_GOT16
6321                       && mips_elf_local_relocation_p (input_bfd, rel,
6322                                                       local_sections, FALSE)))
6323                 {
6324                   bfd_vma l;
6325                   const Elf_Internal_Rela *lo16_relocation;
6326                   reloc_howto_type *lo16_howto;
6327                   unsigned int lo;
6328
6329                   /* The combined value is the sum of the HI16 addend,
6330                      left-shifted by sixteen bits, and the LO16
6331                      addend, sign extended.  (Usually, the code does
6332                      a `lui' of the HI16 value, and then an `addiu' of
6333                      the LO16 value.)
6334
6335                      Scan ahead to find a matching LO16 relocation.  */
6336                   if (r_type == R_MIPS_GNU_REL_HI16)
6337                     lo = R_MIPS_GNU_REL_LO16;
6338                   else
6339                     lo = R_MIPS_LO16;
6340                   lo16_relocation = mips_elf_next_relocation (input_bfd, lo,
6341                                                               rel, relend);
6342                   if (lo16_relocation == NULL)
6343                     return FALSE;
6344
6345                   /* Obtain the addend kept there.  */
6346                   lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, lo, FALSE);
6347                   l = mips_elf_obtain_contents (lo16_howto, lo16_relocation,
6348                                                 input_bfd, contents);
6349                   l &= lo16_howto->src_mask;
6350                   l <<= lo16_howto->rightshift;
6351                   l = _bfd_mips_elf_sign_extend (l, 16);
6352
6353                   addend <<= 16;
6354
6355                   /* Compute the combined addend.  */
6356                   addend += l;
6357
6358                   /* If PC-relative, subtract the difference between the
6359                      address of the LO part of the reloc and the address of
6360                      the HI part.  The relocation is relative to the LO
6361                      part, but mips_elf_calculate_relocation() doesn't
6362                      know its address or the difference from the HI part, so
6363                      we subtract that difference here.  See also the
6364                      comment in mips_elf_calculate_relocation().  */
6365                   if (r_type == R_MIPS_GNU_REL_HI16)
6366                     addend -= (lo16_relocation->r_offset - rel->r_offset);
6367                 }
6368               else if (r_type == R_MIPS16_GPREL)
6369                 {
6370                   /* The addend is scrambled in the object file.  See
6371                      mips_elf_perform_relocation for details on the
6372                      format.  */
6373                   addend = (((addend & 0x1f0000) >> 5)
6374                             | ((addend & 0x7e00000) >> 16)
6375                             | (addend & 0x1f));
6376                 }
6377             }
6378           else
6379             addend = rel->r_addend;
6380         }
6381
6382       if (info->relocatable)
6383         {
6384           Elf_Internal_Sym *sym;
6385           unsigned long r_symndx;
6386
6387           if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
6388               && bfd_big_endian (input_bfd))
6389             rel->r_offset -= 4;
6390
6391           /* Since we're just relocating, all we need to do is copy
6392              the relocations back out to the object file, unless
6393              they're against a section symbol, in which case we need
6394              to adjust by the section offset, or unless they're GP
6395              relative in which case we need to adjust by the amount
6396              that we're adjusting GP in this relocatable object.  */
6397
6398           if (! mips_elf_local_relocation_p (input_bfd, rel, local_sections,
6399                                              FALSE))
6400             /* There's nothing to do for non-local relocations.  */
6401             continue;
6402
6403           if (r_type == R_MIPS16_GPREL
6404               || r_type == R_MIPS_GPREL16
6405               || r_type == R_MIPS_GPREL32
6406               || r_type == R_MIPS_LITERAL)
6407             addend -= (_bfd_get_gp_value (output_bfd)
6408                        - _bfd_get_gp_value (input_bfd));
6409
6410           r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
6411           sym = local_syms + r_symndx;
6412           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6413             /* Adjust the addend appropriately.  */
6414             addend += local_sections[r_symndx]->output_offset;
6415
6416           if (howto->partial_inplace)
6417             {
6418               /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6419                  then we only want to write out the high-order 16 bits.
6420                  The subsequent R_MIPS_LO16 will handle the low-order bits.
6421                */
6422               if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
6423                   || r_type == R_MIPS_GNU_REL_HI16)
6424                 addend = mips_elf_high (addend);
6425               else if (r_type == R_MIPS_HIGHER)
6426                 addend = mips_elf_higher (addend);
6427               else if (r_type == R_MIPS_HIGHEST)
6428                 addend = mips_elf_highest (addend);
6429             }
6430
6431           if (rela_relocation_p)
6432             /* If this is a RELA relocation, just update the addend.
6433                We have to cast away constness for REL.  */
6434             rel->r_addend = addend;
6435           else
6436             {
6437               /* Otherwise, we have to write the value back out.  Note
6438                  that we use the source mask, rather than the
6439                  destination mask because the place to which we are
6440                  writing will be source of the addend in the final
6441                  link.  */
6442               addend >>= howto->rightshift;
6443               addend &= howto->src_mask;
6444
6445               if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6446                 /* See the comment above about using R_MIPS_64 in the 32-bit
6447                    ABI.  Here, we need to update the addend.  It would be
6448                    possible to get away with just using the R_MIPS_32 reloc
6449                    but for endianness.  */
6450                 {
6451                   bfd_vma sign_bits;
6452                   bfd_vma low_bits;
6453                   bfd_vma high_bits;
6454
6455                   if (addend & ((bfd_vma) 1 << 31))
6456 #ifdef BFD64
6457                     sign_bits = ((bfd_vma) 1 << 32) - 1;
6458 #else
6459                     sign_bits = -1;
6460 #endif
6461                   else
6462                     sign_bits = 0;
6463
6464                   /* If we don't know that we have a 64-bit type,
6465                      do two separate stores.  */
6466                   if (bfd_big_endian (input_bfd))
6467                     {
6468                       /* Store the sign-bits (which are most significant)
6469                          first.  */
6470                       low_bits = sign_bits;
6471                       high_bits = addend;
6472                     }
6473                   else
6474                     {
6475                       low_bits = addend;
6476                       high_bits = sign_bits;
6477                     }
6478                   bfd_put_32 (input_bfd, low_bits,
6479                               contents + rel->r_offset);
6480                   bfd_put_32 (input_bfd, high_bits,
6481                               contents + rel->r_offset + 4);
6482                   continue;
6483                 }
6484
6485               if (! mips_elf_perform_relocation (info, howto, rel, addend,
6486                                                  input_bfd, input_section,
6487                                                  contents, FALSE))
6488                 return FALSE;
6489             }
6490
6491           /* Go on to the next relocation.  */
6492           continue;
6493         }
6494
6495       /* In the N32 and 64-bit ABIs there may be multiple consecutive
6496          relocations for the same offset.  In that case we are
6497          supposed to treat the output of each relocation as the addend
6498          for the next.  */
6499       if (rel + 1 < relend
6500           && rel->r_offset == rel[1].r_offset
6501           && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
6502         use_saved_addend_p = TRUE;
6503       else
6504         use_saved_addend_p = FALSE;
6505
6506       addend >>= howto->rightshift;
6507
6508       /* Figure out what value we are supposed to relocate.  */
6509       switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
6510                                              input_section, info, rel,
6511                                              addend, howto, local_syms,
6512                                              local_sections, &value,
6513                                              &name, &require_jalx,
6514                                              use_saved_addend_p))
6515         {
6516         case bfd_reloc_continue:
6517           /* There's nothing to do.  */
6518           continue;
6519
6520         case bfd_reloc_undefined:
6521           /* mips_elf_calculate_relocation already called the
6522              undefined_symbol callback.  There's no real point in
6523              trying to perform the relocation at this point, so we
6524              just skip ahead to the next relocation.  */
6525           continue;
6526
6527         case bfd_reloc_notsupported:
6528           msg = _("internal error: unsupported relocation error");
6529           info->callbacks->warning
6530             (info, msg, name, input_bfd, input_section, rel->r_offset);
6531           return FALSE;
6532
6533         case bfd_reloc_overflow:
6534           if (use_saved_addend_p)
6535             /* Ignore overflow until we reach the last relocation for
6536                a given location.  */
6537             ;
6538           else
6539             {
6540               BFD_ASSERT (name != NULL);
6541               if (! ((*info->callbacks->reloc_overflow)
6542                      (info, name, howto->name, (bfd_vma) 0,
6543                       input_bfd, input_section, rel->r_offset)))
6544                 return FALSE;
6545             }
6546           break;
6547
6548         case bfd_reloc_ok:
6549           break;
6550
6551         default:
6552           abort ();
6553           break;
6554         }
6555
6556       /* If we've got another relocation for the address, keep going
6557          until we reach the last one.  */
6558       if (use_saved_addend_p)
6559         {
6560           addend = value;
6561           continue;
6562         }
6563
6564       if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6565         /* See the comment above about using R_MIPS_64 in the 32-bit
6566            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
6567            that calculated the right value.  Now, however, we
6568            sign-extend the 32-bit result to 64-bits, and store it as a
6569            64-bit value.  We are especially generous here in that we
6570            go to extreme lengths to support this usage on systems with
6571            only a 32-bit VMA.  */
6572         {
6573           bfd_vma sign_bits;
6574           bfd_vma low_bits;
6575           bfd_vma high_bits;
6576
6577           if (value & ((bfd_vma) 1 << 31))
6578 #ifdef BFD64
6579             sign_bits = ((bfd_vma) 1 << 32) - 1;
6580 #else
6581             sign_bits = -1;
6582 #endif
6583           else
6584             sign_bits = 0;
6585
6586           /* If we don't know that we have a 64-bit type,
6587              do two separate stores.  */
6588           if (bfd_big_endian (input_bfd))
6589             {
6590               /* Undo what we did above.  */
6591               rel->r_offset -= 4;
6592               /* Store the sign-bits (which are most significant)
6593                  first.  */
6594               low_bits = sign_bits;
6595               high_bits = value;
6596             }
6597           else
6598             {
6599               low_bits = value;
6600               high_bits = sign_bits;
6601             }
6602           bfd_put_32 (input_bfd, low_bits,
6603                       contents + rel->r_offset);
6604           bfd_put_32 (input_bfd, high_bits,
6605                       contents + rel->r_offset + 4);
6606           continue;
6607         }
6608
6609       /* Actually perform the relocation.  */
6610       if (! mips_elf_perform_relocation (info, howto, rel, value,
6611                                          input_bfd, input_section,
6612                                          contents, require_jalx))
6613         return FALSE;
6614     }
6615
6616   return TRUE;
6617 }
6618 \f
6619 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6620    adjust it appropriately now.  */
6621
6622 static void
6623 mips_elf_irix6_finish_dynamic_symbol (abfd, name, sym)
6624      bfd *abfd ATTRIBUTE_UNUSED;
6625      const char *name;
6626      Elf_Internal_Sym *sym;
6627 {
6628   /* The linker script takes care of providing names and values for
6629      these, but we must place them into the right sections.  */
6630   static const char* const text_section_symbols[] = {
6631     "_ftext",
6632     "_etext",
6633     "__dso_displacement",
6634     "__elf_header",
6635     "__program_header_table",
6636     NULL
6637   };
6638
6639   static const char* const data_section_symbols[] = {
6640     "_fdata",
6641     "_edata",
6642     "_end",
6643     "_fbss",
6644     NULL
6645   };
6646
6647   const char* const *p;
6648   int i;
6649
6650   for (i = 0; i < 2; ++i)
6651     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
6652          *p;
6653          ++p)
6654       if (strcmp (*p, name) == 0)
6655         {
6656           /* All of these symbols are given type STT_SECTION by the
6657              IRIX6 linker.  */
6658           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6659
6660           /* The IRIX linker puts these symbols in special sections.  */
6661           if (i == 0)
6662             sym->st_shndx = SHN_MIPS_TEXT;
6663           else
6664             sym->st_shndx = SHN_MIPS_DATA;
6665
6666           break;
6667         }
6668 }
6669
6670 /* Finish up dynamic symbol handling.  We set the contents of various
6671    dynamic sections here.  */
6672
6673 bfd_boolean
6674 _bfd_mips_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
6675      bfd *output_bfd;
6676      struct bfd_link_info *info;
6677      struct elf_link_hash_entry *h;
6678      Elf_Internal_Sym *sym;
6679 {
6680   bfd *dynobj;
6681   bfd_vma gval;
6682   asection *sgot;
6683   asection *smsym;
6684   struct mips_got_info *g, *gg;
6685   const char *name;
6686   struct mips_elf_link_hash_entry *mh;
6687
6688   dynobj = elf_hash_table (info)->dynobj;
6689   gval = sym->st_value;
6690   mh = (struct mips_elf_link_hash_entry *) h;
6691
6692   if (h->plt.offset != (bfd_vma) -1)
6693     {
6694       asection *s;
6695       bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
6696
6697       /* This symbol has a stub.  Set it up.  */
6698
6699       BFD_ASSERT (h->dynindx != -1);
6700
6701       s = bfd_get_section_by_name (dynobj,
6702                                    MIPS_ELF_STUB_SECTION_NAME (dynobj));
6703       BFD_ASSERT (s != NULL);
6704
6705       /* FIXME: Can h->dynindex be more than 64K?  */
6706       if (h->dynindx & 0xffff0000)
6707         return FALSE;
6708
6709       /* Fill the stub.  */
6710       bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub);
6711       bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + 4);
6712       bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
6713       bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, stub + 12);
6714
6715       BFD_ASSERT (h->plt.offset <= s->_raw_size);
6716       memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
6717
6718       /* Mark the symbol as undefined.  plt.offset != -1 occurs
6719          only for the referenced symbol.  */
6720       sym->st_shndx = SHN_UNDEF;
6721
6722       /* The run-time linker uses the st_value field of the symbol
6723          to reset the global offset table entry for this external
6724          to its stub address when unlinking a shared object.  */
6725       gval = s->output_section->vma + s->output_offset + h->plt.offset;
6726       sym->st_value = gval;
6727     }
6728
6729   BFD_ASSERT (h->dynindx != -1
6730               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
6731
6732   sgot = mips_elf_got_section (dynobj, FALSE);
6733   BFD_ASSERT (sgot != NULL);
6734   BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6735   g = mips_elf_section_data (sgot)->u.got_info;
6736   BFD_ASSERT (g != NULL);
6737
6738   /* Run through the global symbol table, creating GOT entries for all
6739      the symbols that need them.  */
6740   if (g->global_gotsym != NULL
6741       && h->dynindx >= g->global_gotsym->dynindx)
6742     {
6743       bfd_vma offset;
6744       bfd_vma value;
6745
6746       value = sym->st_value;
6747       offset = mips_elf_global_got_index (dynobj, output_bfd, h);
6748       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6749     }
6750
6751   if (g->next && h->dynindx != -1)
6752     {
6753       struct mips_got_entry e, *p;
6754       bfd_vma offset;
6755       bfd_vma value;
6756       Elf_Internal_Rela rel[3];
6757       bfd_vma addend = 0;
6758
6759       gg = g;
6760
6761       e.abfd = output_bfd;
6762       e.symndx = -1;
6763       e.d.h = (struct mips_elf_link_hash_entry *)h;
6764
6765       if (info->shared
6766           || h->root.type == bfd_link_hash_undefined
6767           || h->root.type == bfd_link_hash_undefweak)
6768         value = 0;
6769       else if (sym->st_value)
6770         value = sym->st_value;
6771       else
6772         value = h->root.u.def.value;
6773
6774       memset (rel, 0, sizeof (rel));
6775       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
6776
6777       for (g = g->next; g->next != gg; g = g->next)
6778         {
6779           if (g->got_entries
6780               && (p = (struct mips_got_entry *) htab_find (g->got_entries,
6781                                                            &e)))
6782             {
6783               offset = p->gotidx;
6784               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
6785
6786               MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6787
6788               if ((info->shared
6789                    || (elf_hash_table (info)->dynamic_sections_created
6790                        && p->d.h != NULL
6791                        && ((p->d.h->root.elf_link_hash_flags
6792                             & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
6793                        && ((p->d.h->root.elf_link_hash_flags
6794                             & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6795                   && ! (mips_elf_create_dynamic_relocation
6796                         (output_bfd, info, rel,
6797                          e.d.h, NULL, value, &addend, sgot)))
6798                 return FALSE;
6799               BFD_ASSERT (addend == 0);
6800             }
6801         }
6802     }
6803
6804   /* Create a .msym entry, if appropriate.  */
6805   smsym = bfd_get_section_by_name (dynobj, ".msym");
6806   if (smsym)
6807     {
6808       Elf32_Internal_Msym msym;
6809
6810       msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
6811       /* It is undocumented what the `1' indicates, but IRIX6 uses
6812          this value.  */
6813       msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
6814       bfd_mips_elf_swap_msym_out
6815         (dynobj, &msym,
6816          ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
6817     }
6818
6819   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
6820   name = h->root.root.string;
6821   if (strcmp (name, "_DYNAMIC") == 0
6822       || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
6823     sym->st_shndx = SHN_ABS;
6824   else if (strcmp (name, "_DYNAMIC_LINK") == 0
6825            || strcmp (name, "_DYNAMIC_LINKING") == 0)
6826     {
6827       sym->st_shndx = SHN_ABS;
6828       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6829       sym->st_value = 1;
6830     }
6831   else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
6832     {
6833       sym->st_shndx = SHN_ABS;
6834       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6835       sym->st_value = elf_gp (output_bfd);
6836     }
6837   else if (SGI_COMPAT (output_bfd))
6838     {
6839       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
6840           || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
6841         {
6842           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6843           sym->st_other = STO_PROTECTED;
6844           sym->st_value = 0;
6845           sym->st_shndx = SHN_MIPS_DATA;
6846         }
6847       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
6848         {
6849           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6850           sym->st_other = STO_PROTECTED;
6851           sym->st_value = mips_elf_hash_table (info)->procedure_count;
6852           sym->st_shndx = SHN_ABS;
6853         }
6854       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
6855         {
6856           if (h->type == STT_FUNC)
6857             sym->st_shndx = SHN_MIPS_TEXT;
6858           else if (h->type == STT_OBJECT)
6859             sym->st_shndx = SHN_MIPS_DATA;
6860         }
6861     }
6862
6863   /* Handle the IRIX6-specific symbols.  */
6864   if (IRIX_COMPAT (output_bfd) == ict_irix6)
6865     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
6866
6867   if (! info->shared)
6868     {
6869       if (! mips_elf_hash_table (info)->use_rld_obj_head
6870           && (strcmp (name, "__rld_map") == 0
6871               || strcmp (name, "__RLD_MAP") == 0))
6872         {
6873           asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
6874           BFD_ASSERT (s != NULL);
6875           sym->st_value = s->output_section->vma + s->output_offset;
6876           bfd_put_32 (output_bfd, (bfd_vma) 0, s->contents);
6877           if (mips_elf_hash_table (info)->rld_value == 0)
6878             mips_elf_hash_table (info)->rld_value = sym->st_value;
6879         }
6880       else if (mips_elf_hash_table (info)->use_rld_obj_head
6881                && strcmp (name, "__rld_obj_head") == 0)
6882         {
6883           /* IRIX6 does not use a .rld_map section.  */
6884           if (IRIX_COMPAT (output_bfd) == ict_irix5
6885               || IRIX_COMPAT (output_bfd) == ict_none)
6886             BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
6887                         != NULL);
6888           mips_elf_hash_table (info)->rld_value = sym->st_value;
6889         }
6890     }
6891
6892   /* If this is a mips16 symbol, force the value to be even.  */
6893   if (sym->st_other == STO_MIPS16
6894       && (sym->st_value & 1) != 0)
6895     --sym->st_value;
6896
6897   return TRUE;
6898 }
6899
6900 /* Finish up the dynamic sections.  */
6901
6902 bfd_boolean
6903 _bfd_mips_elf_finish_dynamic_sections (output_bfd, info)
6904      bfd *output_bfd;
6905      struct bfd_link_info *info;
6906 {
6907   bfd *dynobj;
6908   asection *sdyn;
6909   asection *sgot;
6910   struct mips_got_info *gg, *g;
6911
6912   dynobj = elf_hash_table (info)->dynobj;
6913
6914   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6915
6916   sgot = mips_elf_got_section (dynobj, FALSE);
6917   if (sgot == NULL)
6918     gg = g = NULL;
6919   else
6920     {
6921       BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6922       gg = mips_elf_section_data (sgot)->u.got_info;
6923       BFD_ASSERT (gg != NULL);
6924       g = mips_elf_got_for_ibfd (gg, output_bfd);
6925       BFD_ASSERT (g != NULL);
6926     }
6927
6928   if (elf_hash_table (info)->dynamic_sections_created)
6929     {
6930       bfd_byte *b;
6931
6932       BFD_ASSERT (sdyn != NULL);
6933       BFD_ASSERT (g != NULL);
6934
6935       for (b = sdyn->contents;
6936            b < sdyn->contents + sdyn->_raw_size;
6937            b += MIPS_ELF_DYN_SIZE (dynobj))
6938         {
6939           Elf_Internal_Dyn dyn;
6940           const char *name;
6941           size_t elemsize;
6942           asection *s;
6943           bfd_boolean swap_out_p;
6944
6945           /* Read in the current dynamic entry.  */
6946           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
6947
6948           /* Assume that we're going to modify it and write it out.  */
6949           swap_out_p = TRUE;
6950
6951           switch (dyn.d_tag)
6952             {
6953             case DT_RELENT:
6954               s = mips_elf_rel_dyn_section (dynobj, FALSE);
6955               BFD_ASSERT (s != NULL);
6956               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
6957               break;
6958
6959             case DT_STRSZ:
6960               /* Rewrite DT_STRSZ.  */
6961               dyn.d_un.d_val =
6962                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6963               break;
6964
6965             case DT_PLTGOT:
6966               name = ".got";
6967               goto get_vma;
6968             case DT_MIPS_CONFLICT:
6969               name = ".conflict";
6970               goto get_vma;
6971             case DT_MIPS_LIBLIST:
6972               name = ".liblist";
6973             get_vma:
6974               s = bfd_get_section_by_name (output_bfd, name);
6975               BFD_ASSERT (s != NULL);
6976               dyn.d_un.d_ptr = s->vma;
6977               break;
6978
6979             case DT_MIPS_RLD_VERSION:
6980               dyn.d_un.d_val = 1; /* XXX */
6981               break;
6982
6983             case DT_MIPS_FLAGS:
6984               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
6985               break;
6986
6987             case DT_MIPS_CONFLICTNO:
6988               name = ".conflict";
6989               elemsize = sizeof (Elf32_Conflict);
6990               goto set_elemno;
6991
6992             case DT_MIPS_LIBLISTNO:
6993               name = ".liblist";
6994               elemsize = sizeof (Elf32_Lib);
6995             set_elemno:
6996               s = bfd_get_section_by_name (output_bfd, name);
6997               if (s != NULL)
6998                 {
6999                   if (s->_cooked_size != 0)
7000                     dyn.d_un.d_val = s->_cooked_size / elemsize;
7001                   else
7002                     dyn.d_un.d_val = s->_raw_size / elemsize;
7003                 }
7004               else
7005                 dyn.d_un.d_val = 0;
7006               break;
7007
7008             case DT_MIPS_TIME_STAMP:
7009               time ((time_t *) &dyn.d_un.d_val);
7010               break;
7011
7012             case DT_MIPS_ICHECKSUM:
7013               /* XXX FIXME: */
7014               swap_out_p = FALSE;
7015               break;
7016
7017             case DT_MIPS_IVERSION:
7018               /* XXX FIXME: */
7019               swap_out_p = FALSE;
7020               break;
7021
7022             case DT_MIPS_BASE_ADDRESS:
7023               s = output_bfd->sections;
7024               BFD_ASSERT (s != NULL);
7025               dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
7026               break;
7027
7028             case DT_MIPS_LOCAL_GOTNO:
7029               dyn.d_un.d_val = g->local_gotno;
7030               break;
7031
7032             case DT_MIPS_UNREFEXTNO:
7033               /* The index into the dynamic symbol table which is the
7034                  entry of the first external symbol that is not
7035                  referenced within the same object.  */
7036               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
7037               break;
7038
7039             case DT_MIPS_GOTSYM:
7040               if (gg->global_gotsym)
7041                 {
7042                   dyn.d_un.d_val = gg->global_gotsym->dynindx;
7043                   break;
7044                 }
7045               /* In case if we don't have global got symbols we default
7046                  to setting DT_MIPS_GOTSYM to the same value as
7047                  DT_MIPS_SYMTABNO, so we just fall through.  */
7048
7049             case DT_MIPS_SYMTABNO:
7050               name = ".dynsym";
7051               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
7052               s = bfd_get_section_by_name (output_bfd, name);
7053               BFD_ASSERT (s != NULL);
7054
7055               if (s->_cooked_size != 0)
7056                 dyn.d_un.d_val = s->_cooked_size / elemsize;
7057               else
7058                 dyn.d_un.d_val = s->_raw_size / elemsize;
7059               break;
7060
7061             case DT_MIPS_HIPAGENO:
7062               dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
7063               break;
7064
7065             case DT_MIPS_RLD_MAP:
7066               dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
7067               break;
7068
7069             case DT_MIPS_OPTIONS:
7070               s = (bfd_get_section_by_name
7071                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
7072               dyn.d_un.d_ptr = s->vma;
7073               break;
7074
7075             case DT_MIPS_MSYM:
7076               s = (bfd_get_section_by_name (output_bfd, ".msym"));
7077               dyn.d_un.d_ptr = s->vma;
7078               break;
7079
7080             default:
7081               swap_out_p = FALSE;
7082               break;
7083             }
7084
7085           if (swap_out_p)
7086             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
7087               (dynobj, &dyn, b);
7088         }
7089     }
7090
7091   /* The first entry of the global offset table will be filled at
7092      runtime. The second entry will be used by some runtime loaders.
7093      This isn't the case of IRIX rld.  */
7094   if (sgot != NULL && sgot->_raw_size > 0)
7095     {
7096       MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
7097       MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
7098                          sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
7099     }
7100
7101   if (sgot != NULL)
7102     elf_section_data (sgot->output_section)->this_hdr.sh_entsize
7103       = MIPS_ELF_GOT_SIZE (output_bfd);
7104
7105   /* Generate dynamic relocations for the non-primary gots.  */
7106   if (gg != NULL && gg->next)
7107     {
7108       Elf_Internal_Rela rel[3];
7109       bfd_vma addend = 0;
7110
7111       memset (rel, 0, sizeof (rel));
7112       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
7113
7114       for (g = gg->next; g->next != gg; g = g->next)
7115         {
7116           bfd_vma index = g->next->local_gotno + g->next->global_gotno;
7117
7118           MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents
7119                              + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7120           MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000, sgot->contents
7121                              + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7122
7123           if (! info->shared)
7124             continue;
7125
7126           while (index < g->assigned_gotno)
7127             {
7128               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
7129                 = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
7130               if (!(mips_elf_create_dynamic_relocation
7131                     (output_bfd, info, rel, NULL,
7132                      bfd_abs_section_ptr,
7133                      0, &addend, sgot)))
7134                 return FALSE;
7135               BFD_ASSERT (addend == 0);
7136             }
7137         }
7138     }
7139
7140   {
7141     asection *smsym;
7142     asection *s;
7143     Elf32_compact_rel cpt;
7144
7145     /* ??? The section symbols for the output sections were set up in
7146        _bfd_elf_final_link.  SGI sets the STT_NOTYPE attribute for these
7147        symbols.  Should we do so?  */
7148
7149     smsym = bfd_get_section_by_name (dynobj, ".msym");
7150     if (smsym != NULL)
7151       {
7152         Elf32_Internal_Msym msym;
7153
7154         msym.ms_hash_value = 0;
7155         msym.ms_info = ELF32_MS_INFO (0, 1);
7156
7157         for (s = output_bfd->sections; s != NULL; s = s->next)
7158           {
7159             long dynindx = elf_section_data (s)->dynindx;
7160
7161             bfd_mips_elf_swap_msym_out
7162               (output_bfd, &msym,
7163                (((Elf32_External_Msym *) smsym->contents)
7164                 + dynindx));
7165           }
7166       }
7167
7168     if (SGI_COMPAT (output_bfd))
7169       {
7170         /* Write .compact_rel section out.  */
7171         s = bfd_get_section_by_name (dynobj, ".compact_rel");
7172         if (s != NULL)
7173           {
7174             cpt.id1 = 1;
7175             cpt.num = s->reloc_count;
7176             cpt.id2 = 2;
7177             cpt.offset = (s->output_section->filepos
7178                           + sizeof (Elf32_External_compact_rel));
7179             cpt.reserved0 = 0;
7180             cpt.reserved1 = 0;
7181             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
7182                                             ((Elf32_External_compact_rel *)
7183                                              s->contents));
7184
7185             /* Clean up a dummy stub function entry in .text.  */
7186             s = bfd_get_section_by_name (dynobj,
7187                                          MIPS_ELF_STUB_SECTION_NAME (dynobj));
7188             if (s != NULL)
7189               {
7190                 file_ptr dummy_offset;
7191
7192                 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
7193                 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
7194                 memset (s->contents + dummy_offset, 0,
7195                         MIPS_FUNCTION_STUB_SIZE);
7196               }
7197           }
7198       }
7199
7200     /* We need to sort the entries of the dynamic relocation section.  */
7201
7202     s = mips_elf_rel_dyn_section (dynobj, FALSE);
7203
7204     if (s != NULL
7205         && s->_raw_size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
7206       {
7207         reldyn_sorting_bfd = output_bfd;
7208
7209         if (ABI_64_P (output_bfd))
7210           qsort ((Elf64_External_Rel *) s->contents + 1,
7211                  (size_t) s->reloc_count - 1,
7212                  sizeof (Elf64_Mips_External_Rel), sort_dynamic_relocs_64);
7213         else
7214           qsort ((Elf32_External_Rel *) s->contents + 1,
7215                  (size_t) s->reloc_count - 1,
7216                  sizeof (Elf32_External_Rel), sort_dynamic_relocs);
7217       }
7218   }
7219
7220   return TRUE;
7221 }
7222
7223
7224 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
7225
7226 static void
7227 mips_set_isa_flags (abfd)
7228      bfd *abfd;
7229 {
7230   flagword val;
7231
7232   switch (bfd_get_mach (abfd))
7233     {
7234     default:
7235     case bfd_mach_mips3000:
7236       val = E_MIPS_ARCH_1;
7237       break;
7238
7239     case bfd_mach_mips3900:
7240       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
7241       break;
7242
7243     case bfd_mach_mips6000:
7244       val = E_MIPS_ARCH_2;
7245       break;
7246
7247     case bfd_mach_mips4000:
7248     case bfd_mach_mips4300:
7249     case bfd_mach_mips4400:
7250     case bfd_mach_mips4600:
7251       val = E_MIPS_ARCH_3;
7252       break;
7253
7254     case bfd_mach_mips4010:
7255       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
7256       break;
7257
7258     case bfd_mach_mips4100:
7259       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
7260       break;
7261
7262     case bfd_mach_mips4111:
7263       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
7264       break;
7265
7266     case bfd_mach_mips4120:
7267       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
7268       break;
7269
7270     case bfd_mach_mips4650:
7271       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
7272       break;
7273
7274     case bfd_mach_mips5400:
7275       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
7276       break;
7277
7278     case bfd_mach_mips5500:
7279       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
7280       break;
7281
7282     case bfd_mach_mips5000:
7283     case bfd_mach_mips8000:
7284     case bfd_mach_mips10000:
7285     case bfd_mach_mips12000:
7286       val = E_MIPS_ARCH_4;
7287       break;
7288
7289     case bfd_mach_mips5:
7290       val = E_MIPS_ARCH_5;
7291       break;
7292
7293     case bfd_mach_mips_sb1:
7294       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
7295       break;
7296
7297     case bfd_mach_mipsisa32:
7298       val = E_MIPS_ARCH_32;
7299       break;
7300
7301     case bfd_mach_mipsisa64:
7302       val = E_MIPS_ARCH_64;
7303       break;
7304
7305     case bfd_mach_mipsisa32r2:
7306       val = E_MIPS_ARCH_32R2;
7307       break;
7308     }
7309   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
7310   elf_elfheader (abfd)->e_flags |= val;
7311
7312 }
7313
7314
7315 /* The final processing done just before writing out a MIPS ELF object
7316    file.  This gets the MIPS architecture right based on the machine
7317    number.  This is used by both the 32-bit and the 64-bit ABI.  */
7318
7319 void
7320 _bfd_mips_elf_final_write_processing (abfd, linker)
7321      bfd *abfd;
7322      bfd_boolean linker ATTRIBUTE_UNUSED;
7323 {
7324   unsigned int i;
7325   Elf_Internal_Shdr **hdrpp;
7326   const char *name;
7327   asection *sec;
7328
7329   /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7330      is nonzero.  This is for compatibility with old objects, which used
7331      a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
7332   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
7333     mips_set_isa_flags (abfd);
7334
7335   /* Set the sh_info field for .gptab sections and other appropriate
7336      info for each special section.  */
7337   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
7338        i < elf_numsections (abfd);
7339        i++, hdrpp++)
7340     {
7341       switch ((*hdrpp)->sh_type)
7342         {
7343         case SHT_MIPS_MSYM:
7344         case SHT_MIPS_LIBLIST:
7345           sec = bfd_get_section_by_name (abfd, ".dynstr");
7346           if (sec != NULL)
7347             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7348           break;
7349
7350         case SHT_MIPS_GPTAB:
7351           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7352           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7353           BFD_ASSERT (name != NULL
7354                       && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
7355           sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
7356           BFD_ASSERT (sec != NULL);
7357           (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7358           break;
7359
7360         case SHT_MIPS_CONTENT:
7361           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7362           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7363           BFD_ASSERT (name != NULL
7364                       && strncmp (name, ".MIPS.content",
7365                                   sizeof ".MIPS.content" - 1) == 0);
7366           sec = bfd_get_section_by_name (abfd,
7367                                          name + sizeof ".MIPS.content" - 1);
7368           BFD_ASSERT (sec != NULL);
7369           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7370           break;
7371
7372         case SHT_MIPS_SYMBOL_LIB:
7373           sec = bfd_get_section_by_name (abfd, ".dynsym");
7374           if (sec != NULL)
7375             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7376           sec = bfd_get_section_by_name (abfd, ".liblist");
7377           if (sec != NULL)
7378             (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7379           break;
7380
7381         case SHT_MIPS_EVENTS:
7382           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7383           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7384           BFD_ASSERT (name != NULL);
7385           if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7386             sec = bfd_get_section_by_name (abfd,
7387                                            name + sizeof ".MIPS.events" - 1);
7388           else
7389             {
7390               BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
7391                                    sizeof ".MIPS.post_rel" - 1) == 0);
7392               sec = bfd_get_section_by_name (abfd,
7393                                              (name
7394                                               + sizeof ".MIPS.post_rel" - 1));
7395             }
7396           BFD_ASSERT (sec != NULL);
7397           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7398           break;
7399
7400         }
7401     }
7402 }
7403 \f
7404 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7405    segments.  */
7406
7407 int
7408 _bfd_mips_elf_additional_program_headers (abfd)
7409      bfd *abfd;
7410 {
7411   asection *s;
7412   int ret = 0;
7413
7414   /* See if we need a PT_MIPS_REGINFO segment.  */
7415   s = bfd_get_section_by_name (abfd, ".reginfo");
7416   if (s && (s->flags & SEC_LOAD))
7417     ++ret;
7418
7419   /* See if we need a PT_MIPS_OPTIONS segment.  */
7420   if (IRIX_COMPAT (abfd) == ict_irix6
7421       && bfd_get_section_by_name (abfd,
7422                                   MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
7423     ++ret;
7424
7425   /* See if we need a PT_MIPS_RTPROC segment.  */
7426   if (IRIX_COMPAT (abfd) == ict_irix5
7427       && bfd_get_section_by_name (abfd, ".dynamic")
7428       && bfd_get_section_by_name (abfd, ".mdebug"))
7429     ++ret;
7430
7431   return ret;
7432 }
7433
7434 /* Modify the segment map for an IRIX5 executable.  */
7435
7436 bfd_boolean
7437 _bfd_mips_elf_modify_segment_map (abfd)
7438      bfd *abfd;
7439 {
7440   asection *s;
7441   struct elf_segment_map *m, **pm;
7442   bfd_size_type amt;
7443
7444   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7445      segment.  */
7446   s = bfd_get_section_by_name (abfd, ".reginfo");
7447   if (s != NULL && (s->flags & SEC_LOAD) != 0)
7448     {
7449       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7450         if (m->p_type == PT_MIPS_REGINFO)
7451           break;
7452       if (m == NULL)
7453         {
7454           amt = sizeof *m;
7455           m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7456           if (m == NULL)
7457             return FALSE;
7458
7459           m->p_type = PT_MIPS_REGINFO;
7460           m->count = 1;
7461           m->sections[0] = s;
7462
7463           /* We want to put it after the PHDR and INTERP segments.  */
7464           pm = &elf_tdata (abfd)->segment_map;
7465           while (*pm != NULL
7466                  && ((*pm)->p_type == PT_PHDR
7467                      || (*pm)->p_type == PT_INTERP))
7468             pm = &(*pm)->next;
7469
7470           m->next = *pm;
7471           *pm = m;
7472         }
7473     }
7474
7475   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7476      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
7477      PT_OPTIONS segment immediately following the program header
7478      table.  */
7479   if (NEWABI_P (abfd)
7480       /* On non-IRIX6 new abi, we'll have already created a segment
7481          for this section, so don't create another.  I'm not sure this
7482          is not also the case for IRIX 6, but I can't test it right
7483          now.  */
7484       && IRIX_COMPAT (abfd) == ict_irix6)
7485     {
7486       for (s = abfd->sections; s; s = s->next)
7487         if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
7488           break;
7489
7490       if (s)
7491         {
7492           struct elf_segment_map *options_segment;
7493
7494           /* Usually, there's a program header table.  But, sometimes
7495              there's not (like when running the `ld' testsuite).  So,
7496              if there's no program header table, we just put the
7497              options segment at the end.  */
7498           for (pm = &elf_tdata (abfd)->segment_map;
7499                *pm != NULL;
7500                pm = &(*pm)->next)
7501             if ((*pm)->p_type == PT_PHDR)
7502               break;
7503
7504           amt = sizeof (struct elf_segment_map);
7505           options_segment = bfd_zalloc (abfd, amt);
7506           options_segment->next = *pm;
7507           options_segment->p_type = PT_MIPS_OPTIONS;
7508           options_segment->p_flags = PF_R;
7509           options_segment->p_flags_valid = TRUE;
7510           options_segment->count = 1;
7511           options_segment->sections[0] = s;
7512           *pm = options_segment;
7513         }
7514     }
7515   else
7516     {
7517       if (IRIX_COMPAT (abfd) == ict_irix5)
7518         {
7519           /* If there are .dynamic and .mdebug sections, we make a room
7520              for the RTPROC header.  FIXME: Rewrite without section names.  */
7521           if (bfd_get_section_by_name (abfd, ".interp") == NULL
7522               && bfd_get_section_by_name (abfd, ".dynamic") != NULL
7523               && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
7524             {
7525               for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7526                 if (m->p_type == PT_MIPS_RTPROC)
7527                   break;
7528               if (m == NULL)
7529                 {
7530                   amt = sizeof *m;
7531                   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7532                   if (m == NULL)
7533                     return FALSE;
7534
7535                   m->p_type = PT_MIPS_RTPROC;
7536
7537                   s = bfd_get_section_by_name (abfd, ".rtproc");
7538                   if (s == NULL)
7539                     {
7540                       m->count = 0;
7541                       m->p_flags = 0;
7542                       m->p_flags_valid = 1;
7543                     }
7544                   else
7545                     {
7546                       m->count = 1;
7547                       m->sections[0] = s;
7548                     }
7549
7550                   /* We want to put it after the DYNAMIC segment.  */
7551                   pm = &elf_tdata (abfd)->segment_map;
7552                   while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
7553                     pm = &(*pm)->next;
7554                   if (*pm != NULL)
7555                     pm = &(*pm)->next;
7556
7557                   m->next = *pm;
7558                   *pm = m;
7559                 }
7560             }
7561         }
7562       /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7563          .dynstr, .dynsym, and .hash sections, and everything in
7564          between.  */
7565       for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
7566            pm = &(*pm)->next)
7567         if ((*pm)->p_type == PT_DYNAMIC)
7568           break;
7569       m = *pm;
7570       if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
7571         {
7572           /* For a normal mips executable the permissions for the PT_DYNAMIC
7573              segment are read, write and execute. We do that here since
7574              the code in elf.c sets only the read permission. This matters
7575              sometimes for the dynamic linker.  */
7576           if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
7577             {
7578               m->p_flags = PF_R | PF_W | PF_X;
7579               m->p_flags_valid = 1;
7580             }
7581         }
7582       if (m != NULL
7583           && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
7584         {
7585           static const char *sec_names[] =
7586           {
7587             ".dynamic", ".dynstr", ".dynsym", ".hash"
7588           };
7589           bfd_vma low, high;
7590           unsigned int i, c;
7591           struct elf_segment_map *n;
7592
7593           low = 0xffffffff;
7594           high = 0;
7595           for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
7596             {
7597               s = bfd_get_section_by_name (abfd, sec_names[i]);
7598               if (s != NULL && (s->flags & SEC_LOAD) != 0)
7599                 {
7600                   bfd_size_type sz;
7601
7602                   if (low > s->vma)
7603                     low = s->vma;
7604                   sz = s->_cooked_size;
7605                   if (sz == 0)
7606                     sz = s->_raw_size;
7607                   if (high < s->vma + sz)
7608                     high = s->vma + sz;
7609                 }
7610             }
7611
7612           c = 0;
7613           for (s = abfd->sections; s != NULL; s = s->next)
7614             if ((s->flags & SEC_LOAD) != 0
7615                 && s->vma >= low
7616                 && ((s->vma
7617                      + (s->_cooked_size !=
7618                         0 ? s->_cooked_size : s->_raw_size)) <= high))
7619               ++c;
7620
7621           amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
7622           n = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7623           if (n == NULL)
7624             return FALSE;
7625           *n = *m;
7626           n->count = c;
7627
7628           i = 0;
7629           for (s = abfd->sections; s != NULL; s = s->next)
7630             {
7631               if ((s->flags & SEC_LOAD) != 0
7632                   && s->vma >= low
7633                   && ((s->vma
7634                        + (s->_cooked_size != 0 ?
7635                           s->_cooked_size : s->_raw_size)) <= high))
7636                 {
7637                   n->sections[i] = s;
7638                   ++i;
7639                 }
7640             }
7641
7642           *pm = n;
7643         }
7644     }
7645
7646   return TRUE;
7647 }
7648 \f
7649 /* Return the section that should be marked against GC for a given
7650    relocation.  */
7651
7652 asection *
7653 _bfd_mips_elf_gc_mark_hook (sec, info, rel, h, sym)
7654      asection *sec;
7655      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7656      Elf_Internal_Rela *rel;
7657      struct elf_link_hash_entry *h;
7658      Elf_Internal_Sym *sym;
7659 {
7660   /* ??? Do mips16 stub sections need to be handled special?  */
7661
7662   if (h != NULL)
7663     {
7664       switch (ELF_R_TYPE (sec->owner, rel->r_info))
7665         {
7666         case R_MIPS_GNU_VTINHERIT:
7667         case R_MIPS_GNU_VTENTRY:
7668           break;
7669
7670         default:
7671           switch (h->root.type)
7672             {
7673             case bfd_link_hash_defined:
7674             case bfd_link_hash_defweak:
7675               return h->root.u.def.section;
7676
7677             case bfd_link_hash_common:
7678               return h->root.u.c.p->section;
7679
7680             default:
7681               break;
7682             }
7683         }
7684     }
7685   else
7686     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7687
7688   return NULL;
7689 }
7690
7691 /* Update the got entry reference counts for the section being removed.  */
7692
7693 bfd_boolean
7694 _bfd_mips_elf_gc_sweep_hook (abfd, info, sec, relocs)
7695      bfd *abfd ATTRIBUTE_UNUSED;
7696      struct bfd_link_info *info ATTRIBUTE_UNUSED;
7697      asection *sec ATTRIBUTE_UNUSED;
7698      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
7699 {
7700 #if 0
7701   Elf_Internal_Shdr *symtab_hdr;
7702   struct elf_link_hash_entry **sym_hashes;
7703   bfd_signed_vma *local_got_refcounts;
7704   const Elf_Internal_Rela *rel, *relend;
7705   unsigned long r_symndx;
7706   struct elf_link_hash_entry *h;
7707
7708   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7709   sym_hashes = elf_sym_hashes (abfd);
7710   local_got_refcounts = elf_local_got_refcounts (abfd);
7711
7712   relend = relocs + sec->reloc_count;
7713   for (rel = relocs; rel < relend; rel++)
7714     switch (ELF_R_TYPE (abfd, rel->r_info))
7715       {
7716       case R_MIPS_GOT16:
7717       case R_MIPS_CALL16:
7718       case R_MIPS_CALL_HI16:
7719       case R_MIPS_CALL_LO16:
7720       case R_MIPS_GOT_HI16:
7721       case R_MIPS_GOT_LO16:
7722       case R_MIPS_GOT_DISP:
7723       case R_MIPS_GOT_PAGE:
7724       case R_MIPS_GOT_OFST:
7725         /* ??? It would seem that the existing MIPS code does no sort
7726            of reference counting or whatnot on its GOT and PLT entries,
7727            so it is not possible to garbage collect them at this time.  */
7728         break;
7729
7730       default:
7731         break;
7732       }
7733 #endif
7734
7735   return TRUE;
7736 }
7737 \f
7738 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7739    hiding the old indirect symbol.  Process additional relocation
7740    information.  Also called for weakdefs, in which case we just let
7741    _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
7742
7743 void
7744 _bfd_mips_elf_copy_indirect_symbol (bed, dir, ind)
7745      struct elf_backend_data *bed;
7746      struct elf_link_hash_entry *dir, *ind;
7747 {
7748   struct mips_elf_link_hash_entry *dirmips, *indmips;
7749
7750   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
7751
7752   if (ind->root.type != bfd_link_hash_indirect)
7753     return;
7754
7755   dirmips = (struct mips_elf_link_hash_entry *) dir;
7756   indmips = (struct mips_elf_link_hash_entry *) ind;
7757   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
7758   if (indmips->readonly_reloc)
7759     dirmips->readonly_reloc = TRUE;
7760   if (dirmips->min_dyn_reloc_index == 0
7761       || (indmips->min_dyn_reloc_index != 0
7762           && indmips->min_dyn_reloc_index < dirmips->min_dyn_reloc_index))
7763     dirmips->min_dyn_reloc_index = indmips->min_dyn_reloc_index;
7764   if (indmips->no_fn_stub)
7765     dirmips->no_fn_stub = TRUE;
7766 }
7767
7768 void
7769 _bfd_mips_elf_hide_symbol (info, entry, force_local)
7770      struct bfd_link_info *info;
7771      struct elf_link_hash_entry *entry;
7772      bfd_boolean force_local;
7773 {
7774   bfd *dynobj;
7775   asection *got;
7776   struct mips_got_info *g;
7777   struct mips_elf_link_hash_entry *h;
7778
7779   h = (struct mips_elf_link_hash_entry *) entry;
7780   if (h->forced_local)
7781     return;
7782   h->forced_local = force_local;
7783
7784   dynobj = elf_hash_table (info)->dynobj;
7785   if (dynobj != NULL && force_local)
7786     {
7787       got = mips_elf_got_section (dynobj, FALSE);
7788       g = mips_elf_section_data (got)->u.got_info;
7789
7790       if (g->next)
7791         {
7792           struct mips_got_entry e;
7793           struct mips_got_info *gg = g;
7794
7795           /* Since we're turning what used to be a global symbol into a
7796              local one, bump up the number of local entries of each GOT
7797              that had an entry for it.  This will automatically decrease
7798              the number of global entries, since global_gotno is actually
7799              the upper limit of global entries.  */
7800           e.abfd = dynobj;
7801           e.symndx = -1;
7802           e.d.h = h;
7803
7804           for (g = g->next; g != gg; g = g->next)
7805             if (htab_find (g->got_entries, &e))
7806               {
7807                 BFD_ASSERT (g->global_gotno > 0);
7808                 g->local_gotno++;
7809                 g->global_gotno--;
7810               }
7811
7812           /* If this was a global symbol forced into the primary GOT, we
7813              no longer need an entry for it.  We can't release the entry
7814              at this point, but we must at least stop counting it as one
7815              of the symbols that required a forced got entry.  */
7816           if (h->root.got.offset == 2)
7817             {
7818               BFD_ASSERT (gg->assigned_gotno > 0);
7819               gg->assigned_gotno--;
7820             }
7821         }
7822       else if (g->global_gotno == 0 && g->global_gotsym == NULL)
7823         /* If we haven't got through GOT allocation yet, just bump up the
7824            number of local entries, as this symbol won't be counted as
7825            global.  */
7826         g->local_gotno++;
7827       else if (h->root.got.offset == 1)
7828         {
7829           /* If we're past non-multi-GOT allocation and this symbol had
7830              been marked for a global got entry, give it a local entry
7831              instead.  */
7832           BFD_ASSERT (g->global_gotno > 0);
7833           g->local_gotno++;
7834           g->global_gotno--;
7835         }
7836     }
7837
7838   _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
7839 }
7840 \f
7841 #define PDR_SIZE 32
7842
7843 bfd_boolean
7844 _bfd_mips_elf_discard_info (abfd, cookie, info)
7845      bfd *abfd;
7846      struct elf_reloc_cookie *cookie;
7847      struct bfd_link_info *info;
7848 {
7849   asection *o;
7850   bfd_boolean ret = FALSE;
7851   unsigned char *tdata;
7852   size_t i, skip;
7853
7854   o = bfd_get_section_by_name (abfd, ".pdr");
7855   if (! o)
7856     return FALSE;
7857   if (o->_raw_size == 0)
7858     return FALSE;
7859   if (o->_raw_size % PDR_SIZE != 0)
7860     return FALSE;
7861   if (o->output_section != NULL
7862       && bfd_is_abs_section (o->output_section))
7863     return FALSE;
7864
7865   tdata = bfd_zmalloc (o->_raw_size / PDR_SIZE);
7866   if (! tdata)
7867     return FALSE;
7868
7869   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, (PTR) NULL,
7870                                             (Elf_Internal_Rela *) NULL,
7871                                             info->keep_memory);
7872   if (!cookie->rels)
7873     {
7874       free (tdata);
7875       return FALSE;
7876     }
7877
7878   cookie->rel = cookie->rels;
7879   cookie->relend = cookie->rels + o->reloc_count;
7880
7881   for (i = 0, skip = 0; i < o->_raw_size / PDR_SIZE; i ++)
7882     {
7883       if (MNAME(abfd,_bfd_elf,reloc_symbol_deleted_p) (i * PDR_SIZE, cookie))
7884         {
7885           tdata[i] = 1;
7886           skip ++;
7887         }
7888     }
7889
7890   if (skip != 0)
7891     {
7892       mips_elf_section_data (o)->u.tdata = tdata;
7893       o->_cooked_size = o->_raw_size - skip * PDR_SIZE;
7894       ret = TRUE;
7895     }
7896   else
7897     free (tdata);
7898
7899   if (! info->keep_memory)
7900     free (cookie->rels);
7901
7902   return ret;
7903 }
7904
7905 bfd_boolean
7906 _bfd_mips_elf_ignore_discarded_relocs (sec)
7907      asection *sec;
7908 {
7909   if (strcmp (sec->name, ".pdr") == 0)
7910     return TRUE;
7911   return FALSE;
7912 }
7913
7914 bfd_boolean
7915 _bfd_mips_elf_write_section (output_bfd, sec, contents)
7916      bfd *output_bfd;
7917      asection *sec;
7918      bfd_byte *contents;
7919 {
7920   bfd_byte *to, *from, *end;
7921   int i;
7922
7923   if (strcmp (sec->name, ".pdr") != 0)
7924     return FALSE;
7925
7926   if (mips_elf_section_data (sec)->u.tdata == NULL)
7927     return FALSE;
7928
7929   to = contents;
7930   end = contents + sec->_raw_size;
7931   for (from = contents, i = 0;
7932        from < end;
7933        from += PDR_SIZE, i++)
7934     {
7935       if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
7936         continue;
7937       if (to != from)
7938         memcpy (to, from, PDR_SIZE);
7939       to += PDR_SIZE;
7940     }
7941   bfd_set_section_contents (output_bfd, sec->output_section, contents,
7942                             (file_ptr) sec->output_offset,
7943                             sec->_cooked_size);
7944   return TRUE;
7945 }
7946 \f
7947 /* MIPS ELF uses a special find_nearest_line routine in order the
7948    handle the ECOFF debugging information.  */
7949
7950 struct mips_elf_find_line
7951 {
7952   struct ecoff_debug_info d;
7953   struct ecoff_find_line i;
7954 };
7955
7956 bfd_boolean
7957 _bfd_mips_elf_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
7958                                  functionname_ptr, line_ptr)
7959      bfd *abfd;
7960      asection *section;
7961      asymbol **symbols;
7962      bfd_vma offset;
7963      const char **filename_ptr;
7964      const char **functionname_ptr;
7965      unsigned int *line_ptr;
7966 {
7967   asection *msec;
7968
7969   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7970                                      filename_ptr, functionname_ptr,
7971                                      line_ptr))
7972     return TRUE;
7973
7974   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7975                                      filename_ptr, functionname_ptr,
7976                                      line_ptr,
7977                                      (unsigned) (ABI_64_P (abfd) ? 8 : 0),
7978                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7979     return TRUE;
7980
7981   msec = bfd_get_section_by_name (abfd, ".mdebug");
7982   if (msec != NULL)
7983     {
7984       flagword origflags;
7985       struct mips_elf_find_line *fi;
7986       const struct ecoff_debug_swap * const swap =
7987         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
7988
7989       /* If we are called during a link, mips_elf_final_link may have
7990          cleared the SEC_HAS_CONTENTS field.  We force it back on here
7991          if appropriate (which it normally will be).  */
7992       origflags = msec->flags;
7993       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
7994         msec->flags |= SEC_HAS_CONTENTS;
7995
7996       fi = elf_tdata (abfd)->find_line_info;
7997       if (fi == NULL)
7998         {
7999           bfd_size_type external_fdr_size;
8000           char *fraw_src;
8001           char *fraw_end;
8002           struct fdr *fdr_ptr;
8003           bfd_size_type amt = sizeof (struct mips_elf_find_line);
8004
8005           fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
8006           if (fi == NULL)
8007             {
8008               msec->flags = origflags;
8009               return FALSE;
8010             }
8011
8012           if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
8013             {
8014               msec->flags = origflags;
8015               return FALSE;
8016             }
8017
8018           /* Swap in the FDR information.  */
8019           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
8020           fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
8021           if (fi->d.fdr == NULL)
8022             {
8023               msec->flags = origflags;
8024               return FALSE;
8025             }
8026           external_fdr_size = swap->external_fdr_size;
8027           fdr_ptr = fi->d.fdr;
8028           fraw_src = (char *) fi->d.external_fdr;
8029           fraw_end = (fraw_src
8030                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
8031           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
8032             (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
8033
8034           elf_tdata (abfd)->find_line_info = fi;
8035
8036           /* Note that we don't bother to ever free this information.
8037              find_nearest_line is either called all the time, as in
8038              objdump -l, so the information should be saved, or it is
8039              rarely called, as in ld error messages, so the memory
8040              wasted is unimportant.  Still, it would probably be a
8041              good idea for free_cached_info to throw it away.  */
8042         }
8043
8044       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
8045                                   &fi->i, filename_ptr, functionname_ptr,
8046                                   line_ptr))
8047         {
8048           msec->flags = origflags;
8049           return TRUE;
8050         }
8051
8052       msec->flags = origflags;
8053     }
8054
8055   /* Fall back on the generic ELF find_nearest_line routine.  */
8056
8057   return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
8058                                      filename_ptr, functionname_ptr,
8059                                      line_ptr);
8060 }
8061 \f
8062 /* When are writing out the .options or .MIPS.options section,
8063    remember the bytes we are writing out, so that we can install the
8064    GP value in the section_processing routine.  */
8065
8066 bfd_boolean
8067 _bfd_mips_elf_set_section_contents (abfd, section, location, offset, count)
8068      bfd *abfd;
8069      sec_ptr section;
8070      PTR location;
8071      file_ptr offset;
8072      bfd_size_type count;
8073 {
8074   if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8075     {
8076       bfd_byte *c;
8077
8078       if (elf_section_data (section) == NULL)
8079         {
8080           bfd_size_type amt = sizeof (struct bfd_elf_section_data);
8081           section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
8082           if (elf_section_data (section) == NULL)
8083             return FALSE;
8084         }
8085       c = mips_elf_section_data (section)->u.tdata;
8086       if (c == NULL)
8087         {
8088           bfd_size_type size;
8089
8090           if (section->_cooked_size != 0)
8091             size = section->_cooked_size;
8092           else
8093             size = section->_raw_size;
8094           c = (bfd_byte *) bfd_zalloc (abfd, size);
8095           if (c == NULL)
8096             return FALSE;
8097           mips_elf_section_data (section)->u.tdata = c;
8098         }
8099
8100       memcpy (c + offset, location, (size_t) count);
8101     }
8102
8103   return _bfd_elf_set_section_contents (abfd, section, location, offset,
8104                                         count);
8105 }
8106
8107 /* This is almost identical to bfd_generic_get_... except that some
8108    MIPS relocations need to be handled specially.  Sigh.  */
8109
8110 bfd_byte *
8111 _bfd_elf_mips_get_relocated_section_contents (abfd, link_info, link_order,
8112                                               data, relocatable, symbols)
8113      bfd *abfd;
8114      struct bfd_link_info *link_info;
8115      struct bfd_link_order *link_order;
8116      bfd_byte *data;
8117      bfd_boolean relocatable;
8118      asymbol **symbols;
8119 {
8120   /* Get enough memory to hold the stuff */
8121   bfd *input_bfd = link_order->u.indirect.section->owner;
8122   asection *input_section = link_order->u.indirect.section;
8123
8124   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
8125   arelent **reloc_vector = NULL;
8126   long reloc_count;
8127
8128   if (reloc_size < 0)
8129     goto error_return;
8130
8131   reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
8132   if (reloc_vector == NULL && reloc_size != 0)
8133     goto error_return;
8134
8135   /* read in the section */
8136   if (!bfd_get_section_contents (input_bfd,
8137                                  input_section,
8138                                  (PTR) data,
8139                                  (file_ptr) 0,
8140                                  input_section->_raw_size))
8141     goto error_return;
8142
8143   /* We're not relaxing the section, so just copy the size info */
8144   input_section->_cooked_size = input_section->_raw_size;
8145   input_section->reloc_done = TRUE;
8146
8147   reloc_count = bfd_canonicalize_reloc (input_bfd,
8148                                         input_section,
8149                                         reloc_vector,
8150                                         symbols);
8151   if (reloc_count < 0)
8152     goto error_return;
8153
8154   if (reloc_count > 0)
8155     {
8156       arelent **parent;
8157       /* for mips */
8158       int gp_found;
8159       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
8160
8161       {
8162         struct bfd_hash_entry *h;
8163         struct bfd_link_hash_entry *lh;
8164         /* Skip all this stuff if we aren't mixing formats.  */
8165         if (abfd && input_bfd
8166             && abfd->xvec == input_bfd->xvec)
8167           lh = 0;
8168         else
8169           {
8170             h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
8171             lh = (struct bfd_link_hash_entry *) h;
8172           }
8173       lookup:
8174         if (lh)
8175           {
8176             switch (lh->type)
8177               {
8178               case bfd_link_hash_undefined:
8179               case bfd_link_hash_undefweak:
8180               case bfd_link_hash_common:
8181                 gp_found = 0;
8182                 break;
8183               case bfd_link_hash_defined:
8184               case bfd_link_hash_defweak:
8185                 gp_found = 1;
8186                 gp = lh->u.def.value;
8187                 break;
8188               case bfd_link_hash_indirect:
8189               case bfd_link_hash_warning:
8190                 lh = lh->u.i.link;
8191                 /* @@FIXME  ignoring warning for now */
8192                 goto lookup;
8193               case bfd_link_hash_new:
8194               default:
8195                 abort ();
8196               }
8197           }
8198         else
8199           gp_found = 0;
8200       }
8201       /* end mips */
8202       for (parent = reloc_vector; *parent != (arelent *) NULL;
8203            parent++)
8204         {
8205           char *error_message = (char *) NULL;
8206           bfd_reloc_status_type r;
8207
8208           /* Specific to MIPS: Deal with relocation types that require
8209              knowing the gp of the output bfd.  */
8210           asymbol *sym = *(*parent)->sym_ptr_ptr;
8211           if (bfd_is_abs_section (sym->section) && abfd)
8212             {
8213               /* The special_function wouldn't get called anyway.  */
8214             }
8215           else if (!gp_found)
8216             {
8217               /* The gp isn't there; let the special function code
8218                  fall over on its own.  */
8219             }
8220           else if ((*parent)->howto->special_function
8221                    == _bfd_mips_elf32_gprel16_reloc)
8222             {
8223               /* bypass special_function call */
8224               r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
8225                                                  input_section, relocatable,
8226                                                  (PTR) data, gp);
8227               goto skip_bfd_perform_relocation;
8228             }
8229           /* end mips specific stuff */
8230
8231           r = bfd_perform_relocation (input_bfd,
8232                                       *parent,
8233                                       (PTR) data,
8234                                       input_section,
8235                                       relocatable ? abfd : (bfd *) NULL,
8236                                       &error_message);
8237         skip_bfd_perform_relocation:
8238
8239           if (relocatable)
8240             {
8241               asection *os = input_section->output_section;
8242
8243               /* A partial link, so keep the relocs */
8244               os->orelocation[os->reloc_count] = *parent;
8245               os->reloc_count++;
8246             }
8247
8248           if (r != bfd_reloc_ok)
8249             {
8250               switch (r)
8251                 {
8252                 case bfd_reloc_undefined:
8253                   if (!((*link_info->callbacks->undefined_symbol)
8254                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8255                          input_bfd, input_section, (*parent)->address,
8256                          TRUE)))
8257                     goto error_return;
8258                   break;
8259                 case bfd_reloc_dangerous:
8260                   BFD_ASSERT (error_message != (char *) NULL);
8261                   if (!((*link_info->callbacks->reloc_dangerous)
8262                         (link_info, error_message, input_bfd, input_section,
8263                          (*parent)->address)))
8264                     goto error_return;
8265                   break;
8266                 case bfd_reloc_overflow:
8267                   if (!((*link_info->callbacks->reloc_overflow)
8268                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8269                          (*parent)->howto->name, (*parent)->addend,
8270                          input_bfd, input_section, (*parent)->address)))
8271                     goto error_return;
8272                   break;
8273                 case bfd_reloc_outofrange:
8274                 default:
8275                   abort ();
8276                   break;
8277                 }
8278
8279             }
8280         }
8281     }
8282   if (reloc_vector != NULL)
8283     free (reloc_vector);
8284   return data;
8285
8286 error_return:
8287   if (reloc_vector != NULL)
8288     free (reloc_vector);
8289   return NULL;
8290 }
8291 \f
8292 /* Create a MIPS ELF linker hash table.  */
8293
8294 struct bfd_link_hash_table *
8295 _bfd_mips_elf_link_hash_table_create (abfd)
8296      bfd *abfd;
8297 {
8298   struct mips_elf_link_hash_table *ret;
8299   bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
8300
8301   ret = (struct mips_elf_link_hash_table *) bfd_malloc (amt);
8302   if (ret == (struct mips_elf_link_hash_table *) NULL)
8303     return NULL;
8304
8305   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
8306                                        mips_elf_link_hash_newfunc))
8307     {
8308       free (ret);
8309       return NULL;
8310     }
8311
8312 #if 0
8313   /* We no longer use this.  */
8314   for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
8315     ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
8316 #endif
8317   ret->procedure_count = 0;
8318   ret->compact_rel_size = 0;
8319   ret->use_rld_obj_head = FALSE;
8320   ret->rld_value = 0;
8321   ret->mips16_stubs_seen = FALSE;
8322
8323   return &ret->root.root;
8324 }
8325 \f
8326 /* We need to use a special link routine to handle the .reginfo and
8327    the .mdebug sections.  We need to merge all instances of these
8328    sections together, not write them all out sequentially.  */
8329
8330 bfd_boolean
8331 _bfd_mips_elf_final_link (abfd, info)
8332      bfd *abfd;
8333      struct bfd_link_info *info;
8334 {
8335   asection **secpp;
8336   asection *o;
8337   struct bfd_link_order *p;
8338   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
8339   asection *rtproc_sec;
8340   Elf32_RegInfo reginfo;
8341   struct ecoff_debug_info debug;
8342   const struct ecoff_debug_swap *swap
8343     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
8344   HDRR *symhdr = &debug.symbolic_header;
8345   PTR mdebug_handle = NULL;
8346   asection *s;
8347   EXTR esym;
8348   unsigned int i;
8349   bfd_size_type amt;
8350
8351   static const char * const secname[] =
8352   {
8353     ".text", ".init", ".fini", ".data",
8354     ".rodata", ".sdata", ".sbss", ".bss"
8355   };
8356   static const int sc[] =
8357   {
8358     scText, scInit, scFini, scData,
8359     scRData, scSData, scSBss, scBss
8360   };
8361
8362   /* We'd carefully arranged the dynamic symbol indices, and then the
8363      generic size_dynamic_sections renumbered them out from under us.
8364      Rather than trying somehow to prevent the renumbering, just do
8365      the sort again.  */
8366   if (elf_hash_table (info)->dynamic_sections_created)
8367     {
8368       bfd *dynobj;
8369       asection *got;
8370       struct mips_got_info *g;
8371
8372       /* When we resort, we must tell mips_elf_sort_hash_table what
8373          the lowest index it may use is.  That's the number of section
8374          symbols we're going to add.  The generic ELF linker only
8375          adds these symbols when building a shared object.  Note that
8376          we count the sections after (possibly) removing the .options
8377          section above.  */
8378       if (! mips_elf_sort_hash_table (info, (info->shared
8379                                              ? bfd_count_sections (abfd) + 1
8380                                              : 1)))
8381         return FALSE;
8382
8383       /* Make sure we didn't grow the global .got region.  */
8384       dynobj = elf_hash_table (info)->dynobj;
8385       got = mips_elf_got_section (dynobj, FALSE);
8386       g = mips_elf_section_data (got)->u.got_info;
8387
8388       if (g->global_gotsym != NULL)
8389         BFD_ASSERT ((elf_hash_table (info)->dynsymcount
8390                      - g->global_gotsym->dynindx)
8391                     <= g->global_gotno);
8392     }
8393
8394 #if 0
8395   /* We want to set the GP value for ld -r.  */
8396   /* On IRIX5, we omit the .options section.  On IRIX6, however, we
8397      include it, even though we don't process it quite right.  (Some
8398      entries are supposed to be merged.)  Empirically, we seem to be
8399      better off including it then not.  */
8400   if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
8401     for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8402       {
8403         if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8404           {
8405             for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8406               if (p->type == bfd_indirect_link_order)
8407                 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
8408             (*secpp)->link_order_head = NULL;
8409             bfd_section_list_remove (abfd, secpp);
8410             --abfd->section_count;
8411
8412             break;
8413           }
8414       }
8415
8416   /* We include .MIPS.options, even though we don't process it quite right.
8417      (Some entries are supposed to be merged.)  At IRIX6 empirically we seem
8418      to be better off including it than not.  */
8419   for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8420     {
8421       if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
8422         {
8423           for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8424             if (p->type == bfd_indirect_link_order)
8425               p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
8426           (*secpp)->link_order_head = NULL;
8427           bfd_section_list_remove (abfd, secpp);
8428           --abfd->section_count;
8429
8430           break;
8431         }
8432     }
8433 #endif
8434
8435   /* Get a value for the GP register.  */
8436   if (elf_gp (abfd) == 0)
8437     {
8438       struct bfd_link_hash_entry *h;
8439
8440       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
8441       if (h != (struct bfd_link_hash_entry *) NULL
8442           && h->type == bfd_link_hash_defined)
8443         elf_gp (abfd) = (h->u.def.value
8444                          + h->u.def.section->output_section->vma
8445                          + h->u.def.section->output_offset);
8446       else if (info->relocatable)
8447         {
8448           bfd_vma lo = MINUS_ONE;
8449
8450           /* Find the GP-relative section with the lowest offset.  */
8451           for (o = abfd->sections; o != (asection *) NULL; o = o->next)
8452             if (o->vma < lo
8453                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
8454               lo = o->vma;
8455
8456           /* And calculate GP relative to that.  */
8457           elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
8458         }
8459       else
8460         {
8461           /* If the relocate_section function needs to do a reloc
8462              involving the GP value, it should make a reloc_dangerous
8463              callback to warn that GP is not defined.  */
8464         }
8465     }
8466
8467   /* Go through the sections and collect the .reginfo and .mdebug
8468      information.  */
8469   reginfo_sec = NULL;
8470   mdebug_sec = NULL;
8471   gptab_data_sec = NULL;
8472   gptab_bss_sec = NULL;
8473   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
8474     {
8475       if (strcmp (o->name, ".reginfo") == 0)
8476         {
8477           memset (&reginfo, 0, sizeof reginfo);
8478
8479           /* We have found the .reginfo section in the output file.
8480              Look through all the link_orders comprising it and merge
8481              the information together.  */
8482           for (p = o->link_order_head;
8483                p != (struct bfd_link_order *) NULL;
8484                p = p->next)
8485             {
8486               asection *input_section;
8487               bfd *input_bfd;
8488               Elf32_External_RegInfo ext;
8489               Elf32_RegInfo sub;
8490
8491               if (p->type != bfd_indirect_link_order)
8492                 {
8493                   if (p->type == bfd_data_link_order)
8494                     continue;
8495                   abort ();
8496                 }
8497
8498               input_section = p->u.indirect.section;
8499               input_bfd = input_section->owner;
8500
8501               /* The linker emulation code has probably clobbered the
8502                  size to be zero bytes.  */
8503               if (input_section->_raw_size == 0)
8504                 input_section->_raw_size = sizeof (Elf32_External_RegInfo);
8505
8506               if (! bfd_get_section_contents (input_bfd, input_section,
8507                                               (PTR) &ext,
8508                                               (file_ptr) 0,
8509                                               (bfd_size_type) sizeof ext))
8510                 return FALSE;
8511
8512               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
8513
8514               reginfo.ri_gprmask |= sub.ri_gprmask;
8515               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
8516               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
8517               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
8518               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
8519
8520               /* ri_gp_value is set by the function
8521                  mips_elf32_section_processing when the section is
8522                  finally written out.  */
8523
8524               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8525                  elf_link_input_bfd ignores this section.  */
8526               input_section->flags &= ~SEC_HAS_CONTENTS;
8527             }
8528
8529           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
8530           BFD_ASSERT(o->_raw_size == sizeof (Elf32_External_RegInfo));
8531
8532           /* Skip this section later on (I don't think this currently
8533              matters, but someday it might).  */
8534           o->link_order_head = (struct bfd_link_order *) NULL;
8535
8536           reginfo_sec = o;
8537         }
8538
8539       if (strcmp (o->name, ".mdebug") == 0)
8540         {
8541           struct extsym_info einfo;
8542           bfd_vma last;
8543
8544           /* We have found the .mdebug section in the output file.
8545              Look through all the link_orders comprising it and merge
8546              the information together.  */
8547           symhdr->magic = swap->sym_magic;
8548           /* FIXME: What should the version stamp be?  */
8549           symhdr->vstamp = 0;
8550           symhdr->ilineMax = 0;
8551           symhdr->cbLine = 0;
8552           symhdr->idnMax = 0;
8553           symhdr->ipdMax = 0;
8554           symhdr->isymMax = 0;
8555           symhdr->ioptMax = 0;
8556           symhdr->iauxMax = 0;
8557           symhdr->issMax = 0;
8558           symhdr->issExtMax = 0;
8559           symhdr->ifdMax = 0;
8560           symhdr->crfd = 0;
8561           symhdr->iextMax = 0;
8562
8563           /* We accumulate the debugging information itself in the
8564              debug_info structure.  */
8565           debug.line = NULL;
8566           debug.external_dnr = NULL;
8567           debug.external_pdr = NULL;
8568           debug.external_sym = NULL;
8569           debug.external_opt = NULL;
8570           debug.external_aux = NULL;
8571           debug.ss = NULL;
8572           debug.ssext = debug.ssext_end = NULL;
8573           debug.external_fdr = NULL;
8574           debug.external_rfd = NULL;
8575           debug.external_ext = debug.external_ext_end = NULL;
8576
8577           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
8578           if (mdebug_handle == (PTR) NULL)
8579             return FALSE;
8580
8581           esym.jmptbl = 0;
8582           esym.cobol_main = 0;
8583           esym.weakext = 0;
8584           esym.reserved = 0;
8585           esym.ifd = ifdNil;
8586           esym.asym.iss = issNil;
8587           esym.asym.st = stLocal;
8588           esym.asym.reserved = 0;
8589           esym.asym.index = indexNil;
8590           last = 0;
8591           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
8592             {
8593               esym.asym.sc = sc[i];
8594               s = bfd_get_section_by_name (abfd, secname[i]);
8595               if (s != NULL)
8596                 {
8597                   esym.asym.value = s->vma;
8598                   last = s->vma + s->_raw_size;
8599                 }
8600               else
8601                 esym.asym.value = last;
8602               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
8603                                                  secname[i], &esym))
8604                 return FALSE;
8605             }
8606
8607           for (p = o->link_order_head;
8608                p != (struct bfd_link_order *) NULL;
8609                p = p->next)
8610             {
8611               asection *input_section;
8612               bfd *input_bfd;
8613               const struct ecoff_debug_swap *input_swap;
8614               struct ecoff_debug_info input_debug;
8615               char *eraw_src;
8616               char *eraw_end;
8617
8618               if (p->type != bfd_indirect_link_order)
8619                 {
8620                   if (p->type == bfd_data_link_order)
8621                     continue;
8622                   abort ();
8623                 }
8624
8625               input_section = p->u.indirect.section;
8626               input_bfd = input_section->owner;
8627
8628               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
8629                   || (get_elf_backend_data (input_bfd)
8630                       ->elf_backend_ecoff_debug_swap) == NULL)
8631                 {
8632                   /* I don't know what a non MIPS ELF bfd would be
8633                      doing with a .mdebug section, but I don't really
8634                      want to deal with it.  */
8635                   continue;
8636                 }
8637
8638               input_swap = (get_elf_backend_data (input_bfd)
8639                             ->elf_backend_ecoff_debug_swap);
8640
8641               BFD_ASSERT (p->size == input_section->_raw_size);
8642
8643               /* The ECOFF linking code expects that we have already
8644                  read in the debugging information and set up an
8645                  ecoff_debug_info structure, so we do that now.  */
8646               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
8647                                                    &input_debug))
8648                 return FALSE;
8649
8650               if (! (bfd_ecoff_debug_accumulate
8651                      (mdebug_handle, abfd, &debug, swap, input_bfd,
8652                       &input_debug, input_swap, info)))
8653                 return FALSE;
8654
8655               /* Loop through the external symbols.  For each one with
8656                  interesting information, try to find the symbol in
8657                  the linker global hash table and save the information
8658                  for the output external symbols.  */
8659               eraw_src = input_debug.external_ext;
8660               eraw_end = (eraw_src
8661                           + (input_debug.symbolic_header.iextMax
8662                              * input_swap->external_ext_size));
8663               for (;
8664                    eraw_src < eraw_end;
8665                    eraw_src += input_swap->external_ext_size)
8666                 {
8667                   EXTR ext;
8668                   const char *name;
8669                   struct mips_elf_link_hash_entry *h;
8670
8671                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
8672                   if (ext.asym.sc == scNil
8673                       || ext.asym.sc == scUndefined
8674                       || ext.asym.sc == scSUndefined)
8675                     continue;
8676
8677                   name = input_debug.ssext + ext.asym.iss;
8678                   h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
8679                                                  name, FALSE, FALSE, TRUE);
8680                   if (h == NULL || h->esym.ifd != -2)
8681                     continue;
8682
8683                   if (ext.ifd != -1)
8684                     {
8685                       BFD_ASSERT (ext.ifd
8686                                   < input_debug.symbolic_header.ifdMax);
8687                       ext.ifd = input_debug.ifdmap[ext.ifd];
8688                     }
8689
8690                   h->esym = ext;
8691                 }
8692
8693               /* Free up the information we just read.  */
8694               free (input_debug.line);
8695               free (input_debug.external_dnr);
8696               free (input_debug.external_pdr);
8697               free (input_debug.external_sym);
8698               free (input_debug.external_opt);
8699               free (input_debug.external_aux);
8700               free (input_debug.ss);
8701               free (input_debug.ssext);
8702               free (input_debug.external_fdr);
8703               free (input_debug.external_rfd);
8704               free (input_debug.external_ext);
8705
8706               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8707                  elf_link_input_bfd ignores this section.  */
8708               input_section->flags &= ~SEC_HAS_CONTENTS;
8709             }
8710
8711           if (SGI_COMPAT (abfd) && info->shared)
8712             {
8713               /* Create .rtproc section.  */
8714               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8715               if (rtproc_sec == NULL)
8716                 {
8717                   flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
8718                                     | SEC_LINKER_CREATED | SEC_READONLY);
8719
8720                   rtproc_sec = bfd_make_section (abfd, ".rtproc");
8721                   if (rtproc_sec == NULL
8722                       || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
8723                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
8724                     return FALSE;
8725                 }
8726
8727               if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
8728                                                      info, rtproc_sec,
8729                                                      &debug))
8730                 return FALSE;
8731             }
8732
8733           /* Build the external symbol information.  */
8734           einfo.abfd = abfd;
8735           einfo.info = info;
8736           einfo.debug = &debug;
8737           einfo.swap = swap;
8738           einfo.failed = FALSE;
8739           mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8740                                        mips_elf_output_extsym,
8741                                        (PTR) &einfo);
8742           if (einfo.failed)
8743             return FALSE;
8744
8745           /* Set the size of the .mdebug section.  */
8746           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
8747
8748           /* Skip this section later on (I don't think this currently
8749              matters, but someday it might).  */
8750           o->link_order_head = (struct bfd_link_order *) NULL;
8751
8752           mdebug_sec = o;
8753         }
8754
8755       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
8756         {
8757           const char *subname;
8758           unsigned int c;
8759           Elf32_gptab *tab;
8760           Elf32_External_gptab *ext_tab;
8761           unsigned int j;
8762
8763           /* The .gptab.sdata and .gptab.sbss sections hold
8764              information describing how the small data area would
8765              change depending upon the -G switch.  These sections
8766              not used in executables files.  */
8767           if (! info->relocatable)
8768             {
8769               for (p = o->link_order_head;
8770                    p != (struct bfd_link_order *) NULL;
8771                    p = p->next)
8772                 {
8773                   asection *input_section;
8774
8775                   if (p->type != bfd_indirect_link_order)
8776                     {
8777                       if (p->type == bfd_data_link_order)
8778                         continue;
8779                       abort ();
8780                     }
8781
8782                   input_section = p->u.indirect.section;
8783
8784                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
8785                      elf_link_input_bfd ignores this section.  */
8786                   input_section->flags &= ~SEC_HAS_CONTENTS;
8787                 }
8788
8789               /* Skip this section later on (I don't think this
8790                  currently matters, but someday it might).  */
8791               o->link_order_head = (struct bfd_link_order *) NULL;
8792
8793               /* Really remove the section.  */
8794               for (secpp = &abfd->sections;
8795                    *secpp != o;
8796                    secpp = &(*secpp)->next)
8797                 ;
8798               bfd_section_list_remove (abfd, secpp);
8799               --abfd->section_count;
8800
8801               continue;
8802             }
8803
8804           /* There is one gptab for initialized data, and one for
8805              uninitialized data.  */
8806           if (strcmp (o->name, ".gptab.sdata") == 0)
8807             gptab_data_sec = o;
8808           else if (strcmp (o->name, ".gptab.sbss") == 0)
8809             gptab_bss_sec = o;
8810           else
8811             {
8812               (*_bfd_error_handler)
8813                 (_("%s: illegal section name `%s'"),
8814                  bfd_get_filename (abfd), o->name);
8815               bfd_set_error (bfd_error_nonrepresentable_section);
8816               return FALSE;
8817             }
8818
8819           /* The linker script always combines .gptab.data and
8820              .gptab.sdata into .gptab.sdata, and likewise for
8821              .gptab.bss and .gptab.sbss.  It is possible that there is
8822              no .sdata or .sbss section in the output file, in which
8823              case we must change the name of the output section.  */
8824           subname = o->name + sizeof ".gptab" - 1;
8825           if (bfd_get_section_by_name (abfd, subname) == NULL)
8826             {
8827               if (o == gptab_data_sec)
8828                 o->name = ".gptab.data";
8829               else
8830                 o->name = ".gptab.bss";
8831               subname = o->name + sizeof ".gptab" - 1;
8832               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
8833             }
8834
8835           /* Set up the first entry.  */
8836           c = 1;
8837           amt = c * sizeof (Elf32_gptab);
8838           tab = (Elf32_gptab *) bfd_malloc (amt);
8839           if (tab == NULL)
8840             return FALSE;
8841           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
8842           tab[0].gt_header.gt_unused = 0;
8843
8844           /* Combine the input sections.  */
8845           for (p = o->link_order_head;
8846                p != (struct bfd_link_order *) NULL;
8847                p = p->next)
8848             {
8849               asection *input_section;
8850               bfd *input_bfd;
8851               bfd_size_type size;
8852               unsigned long last;
8853               bfd_size_type gpentry;
8854
8855               if (p->type != bfd_indirect_link_order)
8856                 {
8857                   if (p->type == bfd_data_link_order)
8858                     continue;
8859                   abort ();
8860                 }
8861
8862               input_section = p->u.indirect.section;
8863               input_bfd = input_section->owner;
8864
8865               /* Combine the gptab entries for this input section one
8866                  by one.  We know that the input gptab entries are
8867                  sorted by ascending -G value.  */
8868               size = bfd_section_size (input_bfd, input_section);
8869               last = 0;
8870               for (gpentry = sizeof (Elf32_External_gptab);
8871                    gpentry < size;
8872                    gpentry += sizeof (Elf32_External_gptab))
8873                 {
8874                   Elf32_External_gptab ext_gptab;
8875                   Elf32_gptab int_gptab;
8876                   unsigned long val;
8877                   unsigned long add;
8878                   bfd_boolean exact;
8879                   unsigned int look;
8880
8881                   if (! (bfd_get_section_contents
8882                          (input_bfd, input_section, (PTR) &ext_gptab,
8883                           (file_ptr) gpentry,
8884                           (bfd_size_type) sizeof (Elf32_External_gptab))))
8885                     {
8886                       free (tab);
8887                       return FALSE;
8888                     }
8889
8890                   bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
8891                                                 &int_gptab);
8892                   val = int_gptab.gt_entry.gt_g_value;
8893                   add = int_gptab.gt_entry.gt_bytes - last;
8894
8895                   exact = FALSE;
8896                   for (look = 1; look < c; look++)
8897                     {
8898                       if (tab[look].gt_entry.gt_g_value >= val)
8899                         tab[look].gt_entry.gt_bytes += add;
8900
8901                       if (tab[look].gt_entry.gt_g_value == val)
8902                         exact = TRUE;
8903                     }
8904
8905                   if (! exact)
8906                     {
8907                       Elf32_gptab *new_tab;
8908                       unsigned int max;
8909
8910                       /* We need a new table entry.  */
8911                       amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
8912                       new_tab = (Elf32_gptab *) bfd_realloc ((PTR) tab, amt);
8913                       if (new_tab == NULL)
8914                         {
8915                           free (tab);
8916                           return FALSE;
8917                         }
8918                       tab = new_tab;
8919                       tab[c].gt_entry.gt_g_value = val;
8920                       tab[c].gt_entry.gt_bytes = add;
8921
8922                       /* Merge in the size for the next smallest -G
8923                          value, since that will be implied by this new
8924                          value.  */
8925                       max = 0;
8926                       for (look = 1; look < c; look++)
8927                         {
8928                           if (tab[look].gt_entry.gt_g_value < val
8929                               && (max == 0
8930                                   || (tab[look].gt_entry.gt_g_value
8931                                       > tab[max].gt_entry.gt_g_value)))
8932                             max = look;
8933                         }
8934                       if (max != 0)
8935                         tab[c].gt_entry.gt_bytes +=
8936                           tab[max].gt_entry.gt_bytes;
8937
8938                       ++c;
8939                     }
8940
8941                   last = int_gptab.gt_entry.gt_bytes;
8942                 }
8943
8944               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8945                  elf_link_input_bfd ignores this section.  */
8946               input_section->flags &= ~SEC_HAS_CONTENTS;
8947             }
8948
8949           /* The table must be sorted by -G value.  */
8950           if (c > 2)
8951             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
8952
8953           /* Swap out the table.  */
8954           amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
8955           ext_tab = (Elf32_External_gptab *) bfd_alloc (abfd, amt);
8956           if (ext_tab == NULL)
8957             {
8958               free (tab);
8959               return FALSE;
8960             }
8961
8962           for (j = 0; j < c; j++)
8963             bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
8964           free (tab);
8965
8966           o->_raw_size = c * sizeof (Elf32_External_gptab);
8967           o->contents = (bfd_byte *) ext_tab;
8968
8969           /* Skip this section later on (I don't think this currently
8970              matters, but someday it might).  */
8971           o->link_order_head = (struct bfd_link_order *) NULL;
8972         }
8973     }
8974
8975   /* Invoke the regular ELF backend linker to do all the work.  */
8976   if (!MNAME(abfd,bfd_elf,bfd_final_link) (abfd, info))
8977     return FALSE;
8978
8979   /* Now write out the computed sections.  */
8980
8981   if (reginfo_sec != (asection *) NULL)
8982     {
8983       Elf32_External_RegInfo ext;
8984
8985       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
8986       if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
8987                                       (file_ptr) 0,
8988                                       (bfd_size_type) sizeof ext))
8989         return FALSE;
8990     }
8991
8992   if (mdebug_sec != (asection *) NULL)
8993     {
8994       BFD_ASSERT (abfd->output_has_begun);
8995       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
8996                                                swap, info,
8997                                                mdebug_sec->filepos))
8998         return FALSE;
8999
9000       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
9001     }
9002
9003   if (gptab_data_sec != (asection *) NULL)
9004     {
9005       if (! bfd_set_section_contents (abfd, gptab_data_sec,
9006                                       gptab_data_sec->contents,
9007                                       (file_ptr) 0,
9008                                       gptab_data_sec->_raw_size))
9009         return FALSE;
9010     }
9011
9012   if (gptab_bss_sec != (asection *) NULL)
9013     {
9014       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
9015                                       gptab_bss_sec->contents,
9016                                       (file_ptr) 0,
9017                                       gptab_bss_sec->_raw_size))
9018         return FALSE;
9019     }
9020
9021   if (SGI_COMPAT (abfd))
9022     {
9023       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
9024       if (rtproc_sec != NULL)
9025         {
9026           if (! bfd_set_section_contents (abfd, rtproc_sec,
9027                                           rtproc_sec->contents,
9028                                           (file_ptr) 0,
9029                                           rtproc_sec->_raw_size))
9030             return FALSE;
9031         }
9032     }
9033
9034   return TRUE;
9035 }
9036 \f
9037 /* Structure for saying that BFD machine EXTENSION extends BASE.  */
9038
9039 struct mips_mach_extension {
9040   unsigned long extension, base;
9041 };
9042
9043
9044 /* An array describing how BFD machines relate to one another.  The entries
9045    are ordered topologically with MIPS I extensions listed last.  */
9046
9047 static const struct mips_mach_extension mips_mach_extensions[] = {
9048   /* MIPS64 extensions.  */
9049   { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
9050
9051   /* MIPS V extensions.  */
9052   { bfd_mach_mipsisa64, bfd_mach_mips5 },
9053
9054   /* R10000 extensions.  */
9055   { bfd_mach_mips12000, bfd_mach_mips10000 },
9056
9057   /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
9058      vr5400 ISA, but doesn't include the multimedia stuff.  It seems
9059      better to allow vr5400 and vr5500 code to be merged anyway, since
9060      many libraries will just use the core ISA.  Perhaps we could add
9061      some sort of ASE flag if this ever proves a problem.  */
9062   { bfd_mach_mips5500, bfd_mach_mips5400 },
9063   { bfd_mach_mips5400, bfd_mach_mips5000 },
9064
9065   /* MIPS IV extensions.  */
9066   { bfd_mach_mips5, bfd_mach_mips8000 },
9067   { bfd_mach_mips10000, bfd_mach_mips8000 },
9068   { bfd_mach_mips5000, bfd_mach_mips8000 },
9069
9070   /* VR4100 extensions.  */
9071   { bfd_mach_mips4120, bfd_mach_mips4100 },
9072   { bfd_mach_mips4111, bfd_mach_mips4100 },
9073
9074   /* MIPS III extensions.  */
9075   { bfd_mach_mips8000, bfd_mach_mips4000 },
9076   { bfd_mach_mips4650, bfd_mach_mips4000 },
9077   { bfd_mach_mips4600, bfd_mach_mips4000 },
9078   { bfd_mach_mips4400, bfd_mach_mips4000 },
9079   { bfd_mach_mips4300, bfd_mach_mips4000 },
9080   { bfd_mach_mips4100, bfd_mach_mips4000 },
9081   { bfd_mach_mips4010, bfd_mach_mips4000 },
9082
9083   /* MIPS32 extensions.  */
9084   { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
9085
9086   /* MIPS II extensions.  */
9087   { bfd_mach_mips4000, bfd_mach_mips6000 },
9088   { bfd_mach_mipsisa32, bfd_mach_mips6000 },
9089
9090   /* MIPS I extensions.  */
9091   { bfd_mach_mips6000, bfd_mach_mips3000 },
9092   { bfd_mach_mips3900, bfd_mach_mips3000 }
9093 };
9094
9095
9096 /* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
9097
9098 static bfd_boolean
9099 mips_mach_extends_p (base, extension)
9100      unsigned long base, extension;
9101 {
9102   size_t i;
9103
9104   for (i = 0; extension != base && i < ARRAY_SIZE (mips_mach_extensions); i++)
9105     if (extension == mips_mach_extensions[i].extension)
9106       extension = mips_mach_extensions[i].base;
9107
9108   return extension == base;
9109 }
9110
9111
9112 /* Return true if the given ELF header flags describe a 32-bit binary.  */
9113
9114 static bfd_boolean
9115 mips_32bit_flags_p (flags)
9116      flagword flags;
9117 {
9118   return ((flags & EF_MIPS_32BITMODE) != 0
9119           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
9120           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
9121           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
9122           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
9123           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
9124           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
9125 }
9126
9127
9128 /* Merge backend specific data from an object file to the output
9129    object file when linking.  */
9130
9131 bfd_boolean
9132 _bfd_mips_elf_merge_private_bfd_data (ibfd, obfd)
9133      bfd *ibfd;
9134      bfd *obfd;
9135 {
9136   flagword old_flags;
9137   flagword new_flags;
9138   bfd_boolean ok;
9139   bfd_boolean null_input_bfd = TRUE;
9140   asection *sec;
9141
9142   /* Check if we have the same endianess */
9143   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
9144     {
9145       (*_bfd_error_handler)
9146         (_("%s: endianness incompatible with that of the selected emulation"),
9147          bfd_archive_filename (ibfd));
9148       return FALSE;
9149     }
9150
9151   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
9152       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
9153     return TRUE;
9154
9155   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
9156     {
9157       (*_bfd_error_handler)
9158         (_("%s: ABI is incompatible with that of the selected emulation"),
9159          bfd_archive_filename (ibfd));
9160       return FALSE;
9161     }
9162
9163   new_flags = elf_elfheader (ibfd)->e_flags;
9164   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
9165   old_flags = elf_elfheader (obfd)->e_flags;
9166
9167   if (! elf_flags_init (obfd))
9168     {
9169       elf_flags_init (obfd) = TRUE;
9170       elf_elfheader (obfd)->e_flags = new_flags;
9171       elf_elfheader (obfd)->e_ident[EI_CLASS]
9172         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
9173
9174       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
9175           && bfd_get_arch_info (obfd)->the_default)
9176         {
9177           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
9178                                    bfd_get_mach (ibfd)))
9179             return FALSE;
9180         }
9181
9182       return TRUE;
9183     }
9184
9185   /* Check flag compatibility.  */
9186
9187   new_flags &= ~EF_MIPS_NOREORDER;
9188   old_flags &= ~EF_MIPS_NOREORDER;
9189
9190   /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
9191      doesn't seem to matter.  */
9192   new_flags &= ~EF_MIPS_XGOT;
9193   old_flags &= ~EF_MIPS_XGOT;
9194
9195   if (new_flags == old_flags)
9196     return TRUE;
9197
9198   /* Check to see if the input BFD actually contains any sections.
9199      If not, its flags may not have been initialised either, but it cannot
9200      actually cause any incompatibility.  */
9201   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9202     {
9203       /* Ignore synthetic sections and empty .text, .data and .bss sections
9204           which are automatically generated by gas.  */
9205       if (strcmp (sec->name, ".reginfo")
9206           && strcmp (sec->name, ".mdebug")
9207           && ((!strcmp (sec->name, ".text")
9208                || !strcmp (sec->name, ".data")
9209                || !strcmp (sec->name, ".bss"))
9210               && sec->_raw_size != 0))
9211         {
9212           null_input_bfd = FALSE;
9213           break;
9214         }
9215     }
9216   if (null_input_bfd)
9217     return TRUE;
9218
9219   ok = TRUE;
9220
9221   if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
9222       != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
9223     {
9224       (*_bfd_error_handler)
9225         (_("%s: warning: linking PIC files with non-PIC files"),
9226          bfd_archive_filename (ibfd));
9227       ok = TRUE;
9228     }
9229
9230   if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
9231     elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
9232   if (! (new_flags & EF_MIPS_PIC))
9233     elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
9234
9235   new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9236   old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9237
9238   /* Compare the ISAs.  */
9239   if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
9240     {
9241       (*_bfd_error_handler)
9242         (_("%s: linking 32-bit code with 64-bit code"),
9243          bfd_archive_filename (ibfd));
9244       ok = FALSE;
9245     }
9246   else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
9247     {
9248       /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
9249       if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
9250         {
9251           /* Copy the architecture info from IBFD to OBFD.  Also copy
9252              the 32-bit flag (if set) so that we continue to recognise
9253              OBFD as a 32-bit binary.  */
9254           bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
9255           elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
9256           elf_elfheader (obfd)->e_flags
9257             |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9258
9259           /* Copy across the ABI flags if OBFD doesn't use them
9260              and if that was what caused us to treat IBFD as 32-bit.  */
9261           if ((old_flags & EF_MIPS_ABI) == 0
9262               && mips_32bit_flags_p (new_flags)
9263               && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
9264             elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
9265         }
9266       else
9267         {
9268           /* The ISAs aren't compatible.  */
9269           (*_bfd_error_handler)
9270             (_("%s: linking %s module with previous %s modules"),
9271              bfd_archive_filename (ibfd),
9272              bfd_printable_name (ibfd),
9273              bfd_printable_name (obfd));
9274           ok = FALSE;
9275         }
9276     }
9277
9278   new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9279   old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9280
9281   /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
9282      does set EI_CLASS differently from any 32-bit ABI.  */
9283   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
9284       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9285           != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9286     {
9287       /* Only error if both are set (to different values).  */
9288       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
9289           || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9290               != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9291         {
9292           (*_bfd_error_handler)
9293             (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9294              bfd_archive_filename (ibfd),
9295              elf_mips_abi_name (ibfd),
9296              elf_mips_abi_name (obfd));
9297           ok = FALSE;
9298         }
9299       new_flags &= ~EF_MIPS_ABI;
9300       old_flags &= ~EF_MIPS_ABI;
9301     }
9302
9303   /* For now, allow arbitrary mixing of ASEs (retain the union).  */
9304   if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
9305     {
9306       elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
9307
9308       new_flags &= ~ EF_MIPS_ARCH_ASE;
9309       old_flags &= ~ EF_MIPS_ARCH_ASE;
9310     }
9311
9312   /* Warn about any other mismatches */
9313   if (new_flags != old_flags)
9314     {
9315       (*_bfd_error_handler)
9316         (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9317          bfd_archive_filename (ibfd), (unsigned long) new_flags,
9318          (unsigned long) old_flags);
9319       ok = FALSE;
9320     }
9321
9322   if (! ok)
9323     {
9324       bfd_set_error (bfd_error_bad_value);
9325       return FALSE;
9326     }
9327
9328   return TRUE;
9329 }
9330
9331 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
9332
9333 bfd_boolean
9334 _bfd_mips_elf_set_private_flags (abfd, flags)
9335      bfd *abfd;
9336      flagword flags;
9337 {
9338   BFD_ASSERT (!elf_flags_init (abfd)
9339               || elf_elfheader (abfd)->e_flags == flags);
9340
9341   elf_elfheader (abfd)->e_flags = flags;
9342   elf_flags_init (abfd) = TRUE;
9343   return TRUE;
9344 }
9345
9346 bfd_boolean
9347 _bfd_mips_elf_print_private_bfd_data (abfd, ptr)
9348      bfd *abfd;
9349      PTR ptr;
9350 {
9351   FILE *file = (FILE *) ptr;
9352
9353   BFD_ASSERT (abfd != NULL && ptr != NULL);
9354
9355   /* Print normal ELF private data.  */
9356   _bfd_elf_print_private_bfd_data (abfd, ptr);
9357
9358   /* xgettext:c-format */
9359   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
9360
9361   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
9362     fprintf (file, _(" [abi=O32]"));
9363   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
9364     fprintf (file, _(" [abi=O64]"));
9365   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
9366     fprintf (file, _(" [abi=EABI32]"));
9367   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
9368     fprintf (file, _(" [abi=EABI64]"));
9369   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
9370     fprintf (file, _(" [abi unknown]"));
9371   else if (ABI_N32_P (abfd))
9372     fprintf (file, _(" [abi=N32]"));
9373   else if (ABI_64_P (abfd))
9374     fprintf (file, _(" [abi=64]"));
9375   else
9376     fprintf (file, _(" [no abi set]"));
9377
9378   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
9379     fprintf (file, _(" [mips1]"));
9380   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
9381     fprintf (file, _(" [mips2]"));
9382   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
9383     fprintf (file, _(" [mips3]"));
9384   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
9385     fprintf (file, _(" [mips4]"));
9386   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
9387     fprintf (file, _(" [mips5]"));
9388   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
9389     fprintf (file, _(" [mips32]"));
9390   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
9391     fprintf (file, _(" [mips64]"));
9392   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
9393     fprintf (file, _(" [mips32r2]"));
9394   else
9395     fprintf (file, _(" [unknown ISA]"));
9396
9397   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
9398     fprintf (file, _(" [mdmx]"));
9399
9400   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
9401     fprintf (file, _(" [mips16]"));
9402
9403   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
9404     fprintf (file, _(" [32bitmode]"));
9405   else
9406     fprintf (file, _(" [not 32bitmode]"));
9407
9408   fputc ('\n', file);
9409
9410   return TRUE;
9411 }