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