bfd/elfxx-mips.c

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