bfd/elfxx-mips.c

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