contrib/binutils/bfd/elfxx-mips.c

   1 /* MIPS-specific support for ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003 Free Software Foundation, Inc.
   4
   5    Most of the information added by Ian Lance Taylor, Cygnus Support,
   6    <ian@cygnus.com>.
   7    N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
   8    <mark@codesourcery.com>
   9    Traditional MIPS targets support added by Koundinya.K, Dansk Data
  10    Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
  11
  12    This file is part of BFD, the Binary File Descriptor library.
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 2 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  27
  28 /* This file handles functionality common to the different MIPS ABI's.  */
  29
  30 #include "bfd.h"
  31 #include "sysdep.h"
  32 #include "libbfd.h"
  33 #include "libiberty.h"
  34 #include "elf-bfd.h"
  35 #include "elfxx-mips.h"
  36 #include "elf/mips.h"
  37
  38 /* Get the ECOFF swapping routines.  */
  39 #include "coff/sym.h"
  40 #include "coff/symconst.h"
  41 #include "coff/ecoff.h"
  42 #include "coff/mips.h"
  43
  44 #include "hashtab.h"
  45
  46 /* This structure is used to hold .got entries while estimating got
  47    sizes.  */
  48 struct mips_got_entry
  49 {
  50   /* The input bfd in which the symbol is defined.  */
  51   bfd *abfd;
  52   /* The index of the symbol, as stored in the relocation r_info, if
  53      we have a local symbol; -1 otherwise.  */
  54   long symndx;
  55   union
  56   {
  57     /* If abfd == NULL, an address that must be stored in the got.  */
  58     bfd_vma address;
  59     /* If abfd != NULL && symndx != -1, the addend of the relocation
  60        that should be added to the symbol value.  */
  61     bfd_vma addend;
  62     /* If abfd != NULL && symndx == -1, the hash table entry
  63        corresponding to a global symbol in the got (or, local, if
  64        h->forced_local).  */
  65     struct mips_elf_link_hash_entry *h;
  66   } d;
  67   /* The offset from the beginning of the .got section to the entry
  68      corresponding to this symbol+addend.  If it's a global symbol
  69      whose offset is yet to be decided, it's going to be -1.  */
  70   long gotidx;
  71 };
  72
  73 /* This structure is used to hold .got information when linking.  */
  74
  75 struct mips_got_info
  76 {
  77   /* The global symbol in the GOT with the lowest index in the dynamic
  78      symbol table.  */
  79   struct elf_link_hash_entry *global_gotsym;
  80   /* The number of global .got entries.  */
  81   unsigned int global_gotno;
  82   /* The number of local .got entries.  */
  83   unsigned int local_gotno;
  84   /* The number of local .got entries we have used.  */
  85   unsigned int assigned_gotno;
  86   /* A hash table holding members of the got.  */
  87   struct htab *got_entries;
  88   /* A hash table mapping input bfds to other mips_got_info.  NULL
  89      unless multi-got was necessary.  */
  90   struct htab *bfd2got;
  91   /* In multi-got links, a pointer to the next got (err, rather, most
  92      of the time, it points to the previous got).  */
  93   struct mips_got_info *next;
  94 };
  95
  96 /* Map an input bfd to a got in a multi-got link.  */
  97
  98 struct mips_elf_bfd2got_hash {
  99   bfd *bfd;
 100   struct mips_got_info *g;
 101 };
 102
 103 /* Structure passed when traversing the bfd2got hash table, used to
 104    create and merge bfd's gots.  */
 105
 106 struct mips_elf_got_per_bfd_arg
 107 {
 108   /* A hashtable that maps bfds to gots.  */
 109   htab_t bfd2got;
 110   /* The output bfd.  */
 111   bfd *obfd;
 112   /* The link information.  */
 113   struct bfd_link_info *info;
 114   /* A pointer to the primary got, i.e., the one that's going to get
 115      the implicit relocations from DT_MIPS_LOCAL_GOTNO and
 116      DT_MIPS_GOTSYM.  */
 117   struct mips_got_info *primary;
 118   /* A non-primary got we're trying to merge with other input bfd's
 119      gots.  */
 120   struct mips_got_info *current;
 121   /* The maximum number of got entries that can be addressed with a
 122      16-bit offset.  */
 123   unsigned int max_count;
 124   /* The number of local and global entries in the primary got.  */
 125   unsigned int primary_count;
 126   /* The number of local and global entries in the current got.  */
 127   unsigned int current_count;
 128 };
 129
 130 /* Another structure used to pass arguments for got entries traversal.  */
 131
 132 struct mips_elf_set_global_got_offset_arg
 133 {
 134   struct mips_got_info *g;
 135   int value;
 136   unsigned int needed_relocs;
 137   struct bfd_link_info *info;
 138 };
 139
 140 struct _mips_elf_section_data
 141 {
 142   struct bfd_elf_section_data elf;
 143   union
 144   {
 145     struct mips_got_info *got_info;
 146     bfd_byte *tdata;
 147   } u;
 148 };
 149
 150 #define mips_elf_section_data(sec) \
 151   ((struct _mips_elf_section_data *) elf_section_data (sec))
 152
 153 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
 154    the dynamic symbols.  */
 155
 156 struct mips_elf_hash_sort_data
 157 {
 158   /* The symbol in the global GOT with the lowest dynamic symbol table
 159      index.  */
 160   struct elf_link_hash_entry *low;
 161   /* The least dynamic symbol table index corresponding to a symbol
 162      with a GOT entry.  */
 163   long min_got_dynindx;
 164   /* The greatest dynamic symbol table index corresponding to a symbol
 165      with a GOT entry that is not referenced (e.g., a dynamic symbol
 166      with dynamic relocations pointing to it from non-primary GOTs).  */
 167   long max_unref_got_dynindx;
 168   /* The greatest dynamic symbol table index not corresponding to a
 169      symbol without a GOT entry.  */
 170   long max_non_got_dynindx;
 171 };
 172
 173 /* The MIPS ELF linker needs additional information for each symbol in
 174    the global hash table.  */
 175
 176 struct mips_elf_link_hash_entry
 177 {
 178   struct elf_link_hash_entry root;
 179
 180   /* External symbol information.  */
 181   EXTR esym;
 182
 183   /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
 184      this symbol.  */
 185   unsigned int possibly_dynamic_relocs;
 186
 187   /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
 188      a readonly section.  */
 189   bfd_boolean readonly_reloc;
 190
 191   /* We must not create a stub for a symbol that has relocations
 192      related to taking the function's address, i.e. any but
 193      R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
 194      p. 4-20.  */
 195   bfd_boolean no_fn_stub;
 196
 197   /* If there is a stub that 32 bit functions should use to call this
 198      16 bit function, this points to the section containing the stub.  */
 199   asection *fn_stub;
 200
 201   /* Whether we need the fn_stub; this is set if this symbol appears
 202      in any relocs other than a 16 bit call.  */
 203   bfd_boolean need_fn_stub;
 204
 205   /* If there is a stub that 16 bit functions should use to call this
 206      32 bit function, this points to the section containing the stub.  */
 207   asection *call_stub;
 208
 209   /* This is like the call_stub field, but it is used if the function
 210      being called returns a floating point value.  */
 211   asection *call_fp_stub;
 212
 213   /* Are we forced local?  .*/
 214   bfd_boolean forced_local;
 215 };
 216
 217 /* MIPS ELF linker hash table.  */
 218
 219 struct mips_elf_link_hash_table
 220 {
 221   struct elf_link_hash_table root;
 222 #if 0
 223   /* We no longer use this.  */
 224   /* String section indices for the dynamic section symbols.  */
 225   bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
 226 #endif
 227   /* The number of .rtproc entries.  */
 228   bfd_size_type procedure_count;
 229   /* The size of the .compact_rel section (if SGI_COMPAT).  */
 230   bfd_size_type compact_rel_size;
 231   /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
 232      entry is set to the address of __rld_obj_head as in IRIX5.  */
 233   bfd_boolean use_rld_obj_head;
 234   /* This is the value of the __rld_map or __rld_obj_head symbol.  */
 235   bfd_vma rld_value;
 236   /* This is set if we see any mips16 stub sections.  */
 237   bfd_boolean mips16_stubs_seen;
 238 };
 239
 240 /* Structure used to pass information to mips_elf_output_extsym.  */
 241
 242 struct extsym_info
 243 {
 244   bfd *abfd;
 245   struct bfd_link_info *info;
 246   struct ecoff_debug_info *debug;
 247   const struct ecoff_debug_swap *swap;
 248   bfd_boolean failed;
 249 };
 250
 251 /* The names of the runtime procedure table symbols used on IRIX5.  */
 252
 253 static const char * const mips_elf_dynsym_rtproc_names[] =
 254 {
 255   "_procedure_table",
 256   "_procedure_string_table",
 257   "_procedure_table_size",
 258   NULL
 259 };
 260
 261 /* These structures are used to generate the .compact_rel section on
 262    IRIX5.  */
 263
 264 typedef struct
 265 {
 266   unsigned long id1;            /* Always one?  */
 267   unsigned long num;            /* Number of compact relocation entries.  */
 268   unsigned long id2;            /* Always two?  */
 269   unsigned long offset;         /* The file offset of the first relocation.  */
 270   unsigned long reserved0;      /* Zero?  */
 271   unsigned long reserved1;      /* Zero?  */
 272 } Elf32_compact_rel;
 273
 274 typedef struct
 275 {
 276   bfd_byte id1[4];
 277   bfd_byte num[4];
 278   bfd_byte id2[4];
 279   bfd_byte offset[4];
 280   bfd_byte reserved0[4];
 281   bfd_byte reserved1[4];
 282 } Elf32_External_compact_rel;
 283
 284 typedef struct
 285 {
 286   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
 287   unsigned int rtype : 4;       /* Relocation types. See below.  */
 288   unsigned int dist2to : 8;
 289   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
 290   unsigned long konst;          /* KONST field. See below.  */
 291   unsigned long vaddr;          /* VADDR to be relocated.  */
 292 } Elf32_crinfo;
 293
 294 typedef struct
 295 {
 296   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
 297   unsigned int rtype : 4;       /* Relocation types. See below.  */
 298   unsigned int dist2to : 8;
 299   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
 300   unsigned long konst;          /* KONST field. See below.  */
 301 } Elf32_crinfo2;
 302
 303 typedef struct
 304 {
 305   bfd_byte info[4];
 306   bfd_byte konst[4];
 307   bfd_byte vaddr[4];
 308 } Elf32_External_crinfo;
 309
 310 typedef struct
 311 {
 312   bfd_byte info[4];
 313   bfd_byte konst[4];
 314 } Elf32_External_crinfo2;
 315
 316 /* These are the constants used to swap the bitfields in a crinfo.  */
 317
 318 #define CRINFO_CTYPE (0x1)
 319 #define CRINFO_CTYPE_SH (31)
 320 #define CRINFO_RTYPE (0xf)
 321 #define CRINFO_RTYPE_SH (27)
 322 #define CRINFO_DIST2TO (0xff)
 323 #define CRINFO_DIST2TO_SH (19)
 324 #define CRINFO_RELVADDR (0x7ffff)
 325 #define CRINFO_RELVADDR_SH (0)
 326
 327 /* A compact relocation info has long (3 words) or short (2 words)
 328    formats.  A short format doesn't have VADDR field and relvaddr
 329    fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
 330 #define CRF_MIPS_LONG                   1
 331 #define CRF_MIPS_SHORT                  0
 332
 333 /* There are 4 types of compact relocation at least. The value KONST
 334    has different meaning for each type:
 335
 336    (type)               (konst)
 337    CT_MIPS_REL32        Address in data
 338    CT_MIPS_WORD         Address in word (XXX)
 339    CT_MIPS_GPHI_LO      GP - vaddr
 340    CT_MIPS_JMPAD        Address to jump
 341    */
 342
 343 #define CRT_MIPS_REL32                  0xa
 344 #define CRT_MIPS_WORD                   0xb
 345 #define CRT_MIPS_GPHI_LO                0xc
 346 #define CRT_MIPS_JMPAD                  0xd
 347
 348 #define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))
 349 #define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))
 350 #define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))
 351 #define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)
 352 \f
 353 /* The structure of the runtime procedure descriptor created by the
 354    loader for use by the static exception system.  */
 355
 356 typedef struct runtime_pdr {
 357         bfd_vma adr;            /* Memory address of start of procedure.  */
 358         long    regmask;        /* Save register mask.  */
 359         long    regoffset;      /* Save register offset.  */
 360         long    fregmask;       /* Save floating point register mask.  */
 361         long    fregoffset;     /* Save floating point register offset.  */
 362         long    frameoffset;    /* Frame size.  */
 363         short   framereg;       /* Frame pointer register.  */
 364         short   pcreg;          /* Offset or reg of return pc.  */
 365         long    irpss;          /* Index into the runtime string table.  */
 366         long    reserved;
 367         struct exception_info *exception_info;/* Pointer to exception array.  */
 368 } RPDR, *pRPDR;
 369 #define cbRPDR sizeof (RPDR)
 370 #define rpdNil ((pRPDR) 0)
 371 \f
 372 static struct bfd_hash_entry *mips_elf_link_hash_newfunc
 373   (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) != 0)
4884     --sym->st_value;
4885
4886   return TRUE;
4887 }
4888 \f
4889 /* Functions for the dynamic linker.  */
4890
4891 /* Create dynamic sections when linking against a dynamic object.  */
4892
4893 bfd_boolean
4894 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4895 {
4896   struct elf_link_hash_entry *h;
4897   struct bfd_link_hash_entry *bh;
4898   flagword flags;
4899   register asection *s;
4900   const char * const *namep;
4901
4902   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4903            | SEC_LINKER_CREATED | SEC_READONLY);
4904
4905   /* Mips ABI requests the .dynamic section to be read only.  */
4906   s = bfd_get_section_by_name (abfd, ".dynamic");
4907   if (s != NULL)
4908     {
4909       if (! bfd_set_section_flags (abfd, s, flags))
4910         return FALSE;
4911     }
4912
4913   /* We need to create .got section.  */
4914   if (! mips_elf_create_got_section (abfd, info, FALSE))
4915     return FALSE;
4916
4917   if (! mips_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
4918     return FALSE;
4919
4920   /* Create .stub section.  */
4921   if (bfd_get_section_by_name (abfd,
4922                                MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
4923     {
4924       s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
4925       if (s == NULL
4926           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4927           || ! bfd_set_section_alignment (abfd, s,
4928                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4929         return FALSE;
4930     }
4931
4932   if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
4933       && !info->shared
4934       && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
4935     {
4936       s = bfd_make_section (abfd, ".rld_map");
4937       if (s == NULL
4938           || ! bfd_set_section_flags (abfd, s, flags &~ (flagword) SEC_READONLY)
4939           || ! bfd_set_section_alignment (abfd, s,
4940                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4941         return FALSE;
4942     }
4943
4944   /* On IRIX5, we adjust add some additional symbols and change the
4945      alignments of several sections.  There is no ABI documentation
4946      indicating that this is necessary on IRIX6, nor any evidence that
4947      the linker takes such action.  */
4948   if (IRIX_COMPAT (abfd) == ict_irix5)
4949     {
4950       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
4951         {
4952           bh = NULL;
4953           if (! (_bfd_generic_link_add_one_symbol
4954                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
4955                   NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4956             return FALSE;
4957
4958           h = (struct elf_link_hash_entry *) bh;
4959           h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4960           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4961           h->type = STT_SECTION;
4962
4963           if (! bfd_elf_link_record_dynamic_symbol (info, h))
4964             return FALSE;
4965         }
4966
4967       /* We need to create a .compact_rel section.  */
4968       if (SGI_COMPAT (abfd))
4969         {
4970           if (!mips_elf_create_compact_rel_section (abfd, info))
4971             return FALSE;
4972         }
4973
4974       /* Change alignments of some sections.  */
4975       s = bfd_get_section_by_name (abfd, ".hash");
4976       if (s != NULL)
4977         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4978       s = bfd_get_section_by_name (abfd, ".dynsym");
4979       if (s != NULL)
4980         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4981       s = bfd_get_section_by_name (abfd, ".dynstr");
4982       if (s != NULL)
4983         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4984       s = bfd_get_section_by_name (abfd, ".reginfo");
4985       if (s != NULL)
4986         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4987       s = bfd_get_section_by_name (abfd, ".dynamic");
4988       if (s != NULL)
4989         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4990     }
4991
4992   if (!info->shared)
4993     {
4994       const char *name;
4995
4996       name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4997       bh = NULL;
4998       if (!(_bfd_generic_link_add_one_symbol
4999             (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
5000              NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
5001         return FALSE;
5002
5003       h = (struct elf_link_hash_entry *) bh;
5004       h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5005       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5006       h->type = STT_SECTION;
5007
5008       if (! bfd_elf_link_record_dynamic_symbol (info, h))
5009         return FALSE;
5010
5011       if (! mips_elf_hash_table (info)->use_rld_obj_head)
5012         {
5013           /* __rld_map is a four byte word located in the .data section
5014              and is filled in by the rtld to contain a pointer to
5015              the _r_debug structure. Its symbol value will be set in
5016              _bfd_mips_elf_finish_dynamic_symbol.  */
5017           s = bfd_get_section_by_name (abfd, ".rld_map");
5018           BFD_ASSERT (s != NULL);
5019
5020           name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
5021           bh = NULL;
5022           if (!(_bfd_generic_link_add_one_symbol
5023                 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
5024                  get_elf_backend_data (abfd)->collect, &bh)))
5025             return FALSE;
5026
5027           h = (struct elf_link_hash_entry *) bh;
5028           h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5029           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5030           h->type = STT_OBJECT;
5031
5032           if (! bfd_elf_link_record_dynamic_symbol (info, h))
5033             return FALSE;
5034         }
5035     }
5036
5037   return TRUE;
5038 }
5039 \f
5040 /* Look through the relocs for a section during the first phase, and
5041    allocate space in the global offset table.  */
5042
5043 bfd_boolean
5044 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5045                             asection *sec, const Elf_Internal_Rela *relocs)
5046 {
5047   const char *name;
5048   bfd *dynobj;
5049   Elf_Internal_Shdr *symtab_hdr;
5050   struct elf_link_hash_entry **sym_hashes;
5051   struct mips_got_info *g;
5052   size_t extsymoff;
5053   const Elf_Internal_Rela *rel;
5054   const Elf_Internal_Rela *rel_end;
5055   asection *sgot;
5056   asection *sreloc;
5057   const struct elf_backend_data *bed;
5058
5059   if (info->relocatable)
5060     return TRUE;
5061
5062   dynobj = elf_hash_table (info)->dynobj;
5063   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5064   sym_hashes = elf_sym_hashes (abfd);
5065   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5066
5067   /* Check for the mips16 stub sections.  */
5068
5069   name = bfd_get_section_name (abfd, sec);
5070   if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5071     {
5072       unsigned long r_symndx;
5073
5074       /* Look at the relocation information to figure out which symbol
5075          this is for.  */
5076
5077       r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5078
5079       if (r_symndx < extsymoff
5080           || sym_hashes[r_symndx - extsymoff] == NULL)
5081         {
5082           asection *o;
5083
5084           /* This stub is for a local symbol.  This stub will only be
5085              needed if there is some relocation in this BFD, other
5086              than a 16 bit function call, which refers to this symbol.  */
5087           for (o = abfd->sections; o != NULL; o = o->next)
5088             {
5089               Elf_Internal_Rela *sec_relocs;
5090               const Elf_Internal_Rela *r, *rend;
5091
5092               /* We can ignore stub sections when looking for relocs.  */
5093               if ((o->flags & SEC_RELOC) == 0
5094                   || o->reloc_count == 0
5095                   || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5096                               sizeof FN_STUB - 1) == 0
5097                   || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5098                               sizeof CALL_STUB - 1) == 0
5099                   || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5100                               sizeof CALL_FP_STUB - 1) == 0)
5101                 continue;
5102
5103               sec_relocs
5104                 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
5105                                              info->keep_memory);
5106               if (sec_relocs == NULL)
5107                 return FALSE;
5108
5109               rend = sec_relocs + o->reloc_count;
5110               for (r = sec_relocs; r < rend; r++)
5111                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
5112                     && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
5113                   break;
5114
5115               if (elf_section_data (o)->relocs != sec_relocs)
5116                 free (sec_relocs);
5117
5118               if (r < rend)
5119                 break;
5120             }
5121
5122           if (o == NULL)
5123             {
5124               /* There is no non-call reloc for this stub, so we do
5125                  not need it.  Since this function is called before
5126                  the linker maps input sections to output sections, we
5127                  can easily discard it by setting the SEC_EXCLUDE
5128                  flag.  */
5129               sec->flags |= SEC_EXCLUDE;
5130               return TRUE;
5131             }
5132
5133           /* Record this stub in an array of local symbol stubs for
5134              this BFD.  */
5135           if (elf_tdata (abfd)->local_stubs == NULL)
5136             {
5137               unsigned long symcount;
5138               asection **n;
5139               bfd_size_type amt;
5140
5141               if (elf_bad_symtab (abfd))
5142                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5143               else
5144                 symcount = symtab_hdr->sh_info;
5145               amt = symcount * sizeof (asection *);
5146               n = bfd_zalloc (abfd, amt);
5147               if (n == NULL)
5148                 return FALSE;
5149               elf_tdata (abfd)->local_stubs = n;
5150             }
5151
5152           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5153
5154           /* We don't need to set mips16_stubs_seen in this case.
5155              That flag is used to see whether we need to look through
5156              the global symbol table for stubs.  We don't need to set
5157              it here, because we just have a local stub.  */
5158         }
5159       else
5160         {
5161           struct mips_elf_link_hash_entry *h;
5162
5163           h = ((struct mips_elf_link_hash_entry *)
5164                sym_hashes[r_symndx - extsymoff]);
5165
5166           /* H is the symbol this stub is for.  */
5167
5168           h->fn_stub = sec;
5169           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5170         }
5171     }
5172   else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5173            || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5174     {
5175       unsigned long r_symndx;
5176       struct mips_elf_link_hash_entry *h;
5177       asection **loc;
5178
5179       /* Look at the relocation information to figure out which symbol
5180          this is for.  */
5181
5182       r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5183
5184       if (r_symndx < extsymoff
5185           || sym_hashes[r_symndx - extsymoff] == NULL)
5186         {
5187           /* This stub was actually built for a static symbol defined
5188              in the same file.  We assume that all static symbols in
5189              mips16 code are themselves mips16, so we can simply
5190              discard this stub.  Since this function is called before
5191              the linker maps input sections to output sections, we can
5192              easily discard it by setting the SEC_EXCLUDE flag.  */
5193           sec->flags |= SEC_EXCLUDE;
5194           return TRUE;
5195         }
5196
5197       h = ((struct mips_elf_link_hash_entry *)
5198            sym_hashes[r_symndx - extsymoff]);
5199
5200       /* H is the symbol this stub is for.  */
5201
5202       if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5203         loc = &h->call_fp_stub;
5204       else
5205         loc = &h->call_stub;
5206
5207       /* If we already have an appropriate stub for this function, we
5208          don't need another one, so we can discard this one.  Since
5209          this function is called before the linker maps input sections
5210          to output sections, we can easily discard it by setting the
5211          SEC_EXCLUDE flag.  We can also discard this section if we
5212          happen to already know that this is a mips16 function; it is
5213          not necessary to check this here, as it is checked later, but
5214          it is slightly faster to check now.  */
5215       if (*loc != NULL || h->root.other == STO_MIPS16)
5216         {
5217           sec->flags |= SEC_EXCLUDE;
5218           return TRUE;
5219         }
5220
5221       *loc = sec;
5222       mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5223     }
5224
5225   if (dynobj == NULL)
5226     {
5227       sgot = NULL;
5228       g = NULL;
5229     }
5230   else
5231     {
5232       sgot = mips_elf_got_section (dynobj, FALSE);
5233       if (sgot == NULL)
5234         g = NULL;
5235       else
5236         {
5237           BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
5238           g = mips_elf_section_data (sgot)->u.got_info;
5239           BFD_ASSERT (g != NULL);
5240         }
5241     }
5242
5243   sreloc = NULL;
5244   bed = get_elf_backend_data (abfd);
5245   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5246   for (rel = relocs; rel < rel_end; ++rel)
5247     {
5248       unsigned long r_symndx;
5249       unsigned int r_type;
5250       struct elf_link_hash_entry *h;
5251
5252       r_symndx = ELF_R_SYM (abfd, rel->r_info);
5253       r_type = ELF_R_TYPE (abfd, rel->r_info);
5254
5255       if (r_symndx < extsymoff)
5256         h = NULL;
5257       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5258         {
5259           (*_bfd_error_handler)
5260             (_("%s: Malformed reloc detected for section %s"),
5261              bfd_archive_filename (abfd), name);
5262           bfd_set_error (bfd_error_bad_value);
5263           return FALSE;
5264         }
5265       else
5266         {
5267           h = sym_hashes[r_symndx - extsymoff];
5268
5269           /* This may be an indirect symbol created because of a version.  */
5270           if (h != NULL)
5271             {
5272               while (h->root.type == bfd_link_hash_indirect)
5273                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5274             }
5275         }
5276
5277       /* Some relocs require a global offset table.  */
5278       if (dynobj == NULL || sgot == NULL)
5279         {
5280           switch (r_type)
5281             {
5282             case R_MIPS_GOT16:
5283             case R_MIPS_CALL16:
5284             case R_MIPS_CALL_HI16:
5285             case R_MIPS_CALL_LO16:
5286             case R_MIPS_GOT_HI16:
5287             case R_MIPS_GOT_LO16:
5288             case R_MIPS_GOT_PAGE:
5289             case R_MIPS_GOT_OFST:
5290             case R_MIPS_GOT_DISP:
5291               if (dynobj == NULL)
5292                 elf_hash_table (info)->dynobj = dynobj = abfd;
5293               if (! mips_elf_create_got_section (dynobj, info, FALSE))
5294                 return FALSE;
5295               g = mips_elf_got_info (dynobj, &sgot);
5296               break;
5297
5298             case R_MIPS_32:
5299             case R_MIPS_REL32:
5300             case R_MIPS_64:
5301               if (dynobj == NULL
5302                   && (info->shared || h != NULL)
5303                   && (sec->flags & SEC_ALLOC) != 0)
5304                 elf_hash_table (info)->dynobj = dynobj = abfd;
5305               break;
5306
5307             default:
5308               break;
5309             }
5310         }
5311
5312       if (!h && (r_type == R_MIPS_CALL_LO16
5313                  || r_type == R_MIPS_GOT_LO16
5314                  || r_type == R_MIPS_GOT_DISP))
5315         {
5316           /* We may need a local GOT entry for this relocation.  We
5317              don't count R_MIPS_GOT_PAGE because we can estimate the
5318              maximum number of pages needed by looking at the size of
5319              the segment.  Similar comments apply to R_MIPS_GOT16 and
5320              R_MIPS_CALL16.  We don't count R_MIPS_GOT_HI16, or
5321              R_MIPS_CALL_HI16 because these are always followed by an
5322              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
5323           if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
5324                                                   rel->r_addend, g))
5325             return FALSE;
5326         }
5327
5328       switch (r_type)
5329         {
5330         case R_MIPS_CALL16:
5331           if (h == NULL)
5332             {
5333               (*_bfd_error_handler)
5334                 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5335                  bfd_archive_filename (abfd), (unsigned long) rel->r_offset);
5336               bfd_set_error (bfd_error_bad_value);
5337               return FALSE;
5338             }
5339           /* Fall through.  */
5340
5341         case R_MIPS_CALL_HI16:
5342         case R_MIPS_CALL_LO16:
5343           if (h != NULL)
5344             {
5345               /* This symbol requires a global offset table entry.  */
5346               if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5347                 return FALSE;
5348
5349               /* We need a stub, not a plt entry for the undefined
5350                  function.  But we record it as if it needs plt.  See
5351                  _bfd_elf_adjust_dynamic_symbol.  */
5352               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
5353               h->type = STT_FUNC;
5354             }
5355           break;
5356
5357         case R_MIPS_GOT_PAGE:
5358           /* If this is a global, overridable symbol, GOT_PAGE will
5359              decay to GOT_DISP, so we'll need a GOT entry for it.  */
5360           if (h == NULL)
5361             break;
5362           else
5363             {
5364               struct mips_elf_link_hash_entry *hmips =
5365                 (struct mips_elf_link_hash_entry *) h;
5366
5367               while (hmips->root.root.type == bfd_link_hash_indirect
5368                      || hmips->root.root.type == bfd_link_hash_warning)
5369                 hmips = (struct mips_elf_link_hash_entry *)
5370                   hmips->root.root.u.i.link;
5371
5372               if ((hmips->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
5373                   && ! (info->shared && ! info->symbolic
5374                         && ! (hmips->root.elf_link_hash_flags
5375                               & ELF_LINK_FORCED_LOCAL)))
5376                 break;
5377             }
5378           /* Fall through.  */
5379
5380         case R_MIPS_GOT16:
5381         case R_MIPS_GOT_HI16:
5382         case R_MIPS_GOT_LO16:
5383         case R_MIPS_GOT_DISP:
5384           /* This symbol requires a global offset table entry.  */
5385           if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g))
5386             return FALSE;
5387           break;
5388
5389         case R_MIPS_32:
5390         case R_MIPS_REL32:
5391         case R_MIPS_64:
5392           if ((info->shared || h != NULL)
5393               && (sec->flags & SEC_ALLOC) != 0)
5394             {
5395               if (sreloc == NULL)
5396                 {
5397                   sreloc = mips_elf_rel_dyn_section (dynobj, TRUE);
5398                   if (sreloc == NULL)
5399                     return FALSE;
5400                 }
5401 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5402               if (info->shared)
5403                 {
5404                   /* When creating a shared object, we must copy these
5405                      reloc types into the output file as R_MIPS_REL32
5406                      relocs.  We make room for this reloc in the
5407                      .rel.dyn reloc section.  */
5408                   mips_elf_allocate_dynamic_relocations (dynobj, 1);
5409                   if ((sec->flags & MIPS_READONLY_SECTION)
5410                       == MIPS_READONLY_SECTION)
5411                     /* We tell the dynamic linker that there are
5412                        relocations against the text segment.  */
5413                     info->flags |= DF_TEXTREL;
5414                 }
5415               else
5416                 {
5417                   struct mips_elf_link_hash_entry *hmips;
5418
5419                   /* We only need to copy this reloc if the symbol is
5420                      defined in a dynamic object.  */
5421                   hmips = (struct mips_elf_link_hash_entry *) h;
5422                   ++hmips->possibly_dynamic_relocs;
5423                   if ((sec->flags & MIPS_READONLY_SECTION)
5424                       == MIPS_READONLY_SECTION)
5425                     /* We need it to tell the dynamic linker if there
5426                        are relocations against the text segment.  */
5427                     hmips->readonly_reloc = TRUE;
5428                 }
5429
5430               /* Even though we don't directly need a GOT entry for
5431                  this symbol, a symbol must have a dynamic symbol
5432                  table index greater that DT_MIPS_GOTSYM if there are
5433                  dynamic relocations against it.  */
5434               if (h != NULL)
5435                 {
5436                   if (dynobj == NULL)
5437                     elf_hash_table (info)->dynobj = dynobj = abfd;
5438                   if (! mips_elf_create_got_section (dynobj, info, TRUE))
5439                     return FALSE;
5440                   g = mips_elf_got_info (dynobj, &sgot);
5441                   if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5442                     return FALSE;
5443                 }
5444             }
5445
5446           if (SGI_COMPAT (abfd))
5447             mips_elf_hash_table (info)->compact_rel_size +=
5448               sizeof (Elf32_External_crinfo);
5449           break;
5450
5451         case R_MIPS_26:
5452         case R_MIPS_GPREL16:
5453         case R_MIPS_LITERAL:
5454         case R_MIPS_GPREL32:
5455           if (SGI_COMPAT (abfd))
5456             mips_elf_hash_table (info)->compact_rel_size +=
5457               sizeof (Elf32_External_crinfo);
5458           break;
5459
5460           /* This relocation describes the C++ object vtable hierarchy.
5461              Reconstruct it for later use during GC.  */
5462         case R_MIPS_GNU_VTINHERIT:
5463           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5464             return FALSE;
5465           break;
5466
5467           /* This relocation describes which C++ vtable entries are actually
5468              used.  Record for later use during GC.  */
5469         case R_MIPS_GNU_VTENTRY:
5470           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
5471             return FALSE;
5472           break;
5473
5474         default:
5475           break;
5476         }
5477
5478       /* We must not create a stub for a symbol that has relocations
5479          related to taking the function's address.  */
5480       switch (r_type)
5481         {
5482         default:
5483           if (h != NULL)
5484             {
5485               struct mips_elf_link_hash_entry *mh;
5486
5487               mh = (struct mips_elf_link_hash_entry *) h;
5488               mh->no_fn_stub = TRUE;
5489             }
5490           break;
5491         case R_MIPS_CALL16:
5492         case R_MIPS_CALL_HI16:
5493         case R_MIPS_CALL_LO16:
5494         case R_MIPS_JALR:
5495           break;
5496         }
5497
5498       /* If this reloc is not a 16 bit call, and it has a global
5499          symbol, then we will need the fn_stub if there is one.
5500          References from a stub section do not count.  */
5501       if (h != NULL
5502           && r_type != R_MIPS16_26
5503           && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
5504                       sizeof FN_STUB - 1) != 0
5505           && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
5506                       sizeof CALL_STUB - 1) != 0
5507           && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
5508                       sizeof CALL_FP_STUB - 1) != 0)
5509         {
5510           struct mips_elf_link_hash_entry *mh;
5511
5512           mh = (struct mips_elf_link_hash_entry *) h;
5513           mh->need_fn_stub = TRUE;
5514         }
5515     }
5516
5517   return TRUE;
5518 }
5519 \f
5520 bfd_boolean
5521 _bfd_mips_relax_section (bfd *abfd, asection *sec,
5522                          struct bfd_link_info *link_info,
5523                          bfd_boolean *again)
5524 {
5525   Elf_Internal_Rela *internal_relocs;
5526   Elf_Internal_Rela *irel, *irelend;
5527   Elf_Internal_Shdr *symtab_hdr;
5528   bfd_byte *contents = NULL;
5529   bfd_byte *free_contents = NULL;
5530   size_t extsymoff;
5531   bfd_boolean changed_contents = FALSE;
5532   bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
5533   Elf_Internal_Sym *isymbuf = NULL;
5534
5535   /* We are not currently changing any sizes, so only one pass.  */
5536   *again = FALSE;
5537
5538   if (link_info->relocatable)
5539     return TRUE;
5540
5541   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
5542                                                link_info->keep_memory);
5543   if (internal_relocs == NULL)
5544     return TRUE;
5545
5546   irelend = internal_relocs + sec->reloc_count
5547     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
5548   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5549   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5550
5551   for (irel = internal_relocs; irel < irelend; irel++)
5552     {
5553       bfd_vma symval;
5554       bfd_signed_vma sym_offset;
5555       unsigned int r_type;
5556       unsigned long r_symndx;
5557       asection *sym_sec;
5558       unsigned long instruction;
5559
5560       /* Turn jalr into bgezal, and jr into beq, if they're marked
5561          with a JALR relocation, that indicate where they jump to.
5562          This saves some pipeline bubbles.  */
5563       r_type = ELF_R_TYPE (abfd, irel->r_info);
5564       if (r_type != R_MIPS_JALR)
5565         continue;
5566
5567       r_symndx = ELF_R_SYM (abfd, irel->r_info);
5568       /* Compute the address of the jump target.  */
5569       if (r_symndx >= extsymoff)
5570         {
5571           struct mips_elf_link_hash_entry *h
5572             = ((struct mips_elf_link_hash_entry *)
5573                elf_sym_hashes (abfd) [r_symndx - extsymoff]);
5574
5575           while (h->root.root.type == bfd_link_hash_indirect
5576                  || h->root.root.type == bfd_link_hash_warning)
5577             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5578
5579           /* If a symbol is undefined, or if it may be overridden,
5580              skip it.  */
5581           if (! ((h->root.root.type == bfd_link_hash_defined
5582                   || h->root.root.type == bfd_link_hash_defweak)
5583                  && h->root.root.u.def.section)
5584               || (link_info->shared && ! link_info->symbolic
5585                   && ! (h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)))
5586             continue;
5587
5588           sym_sec = h->root.root.u.def.section;
5589           if (sym_sec->output_section)
5590             symval = (h->root.root.u.def.value
5591                       + sym_sec->output_section->vma
5592                       + sym_sec->output_offset);
5593           else
5594             symval = h->root.root.u.def.value;
5595         }
5596       else
5597         {
5598           Elf_Internal_Sym *isym;
5599
5600           /* Read this BFD's symbols if we haven't done so already.  */
5601           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
5602             {
5603               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5604               if (isymbuf == NULL)
5605                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5606                                                 symtab_hdr->sh_info, 0,
5607                                                 NULL, NULL, NULL);
5608               if (isymbuf == NULL)
5609                 goto relax_return;
5610             }
5611
5612           isym = isymbuf + r_symndx;
5613           if (isym->st_shndx == SHN_UNDEF)
5614             continue;
5615           else if (isym->st_shndx == SHN_ABS)
5616             sym_sec = bfd_abs_section_ptr;
5617           else if (isym->st_shndx == SHN_COMMON)
5618             sym_sec = bfd_com_section_ptr;
5619           else
5620             sym_sec
5621               = bfd_section_from_elf_index (abfd, isym->st_shndx);
5622           symval = isym->st_value
5623             + sym_sec->output_section->vma
5624             + sym_sec->output_offset;
5625         }
5626
5627       /* Compute branch offset, from delay slot of the jump to the
5628          branch target.  */
5629       sym_offset = (symval + irel->r_addend)
5630         - (sec_start + irel->r_offset + 4);
5631
5632       /* Branch offset must be properly aligned.  */
5633       if ((sym_offset & 3) != 0)
5634         continue;
5635
5636       sym_offset >>= 2;
5637
5638       /* Check that it's in range.  */
5639       if (sym_offset < -0x8000 || sym_offset >= 0x8000)
5640         continue;
5641
5642       /* Get the section contents if we haven't done so already.  */
5643       if (contents == NULL)
5644         {
5645           /* Get cached copy if it exists.  */
5646           if (elf_section_data (sec)->this_hdr.contents != NULL)
5647             contents = elf_section_data (sec)->this_hdr.contents;
5648           else
5649             {
5650               contents = bfd_malloc (sec->_raw_size);
5651               if (contents == NULL)
5652                 goto relax_return;
5653
5654               free_contents = contents;
5655               if (! bfd_get_section_contents (abfd, sec, contents,
5656                                               0, sec->_raw_size))
5657                 goto relax_return;
5658             }
5659         }
5660
5661       instruction = bfd_get_32 (abfd, contents + irel->r_offset);
5662
5663       /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
5664       if ((instruction & 0xfc1fffff) == 0x0000f809)
5665         instruction = 0x04110000;
5666       /* If it was jr <reg>, turn it into b <target>.  */
5667       else if ((instruction & 0xfc1fffff) == 0x00000008)
5668         instruction = 0x10000000;
5669       else
5670         continue;
5671
5672       instruction |= (sym_offset & 0xffff);
5673       bfd_put_32 (abfd, instruction, contents + irel->r_offset);
5674       changed_contents = TRUE;
5675     }
5676
5677   if (contents != NULL
5678       && elf_section_data (sec)->this_hdr.contents != contents)
5679     {
5680       if (!changed_contents && !link_info->keep_memory)
5681         free (contents);
5682       else
5683         {
5684           /* Cache the section contents for elf_link_input_bfd.  */
5685           elf_section_data (sec)->this_hdr.contents = contents;
5686         }
5687     }
5688   return TRUE;
5689
5690  relax_return:
5691   if (free_contents != NULL)
5692     free (free_contents);
5693   return FALSE;
5694 }
5695 \f
5696 /* Adjust a symbol defined by a dynamic object and referenced by a
5697    regular object.  The current definition is in some section of the
5698    dynamic object, but we're not including those sections.  We have to
5699    change the definition to something the rest of the link can
5700    understand.  */
5701
5702 bfd_boolean
5703 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5704                                      struct elf_link_hash_entry *h)
5705 {
5706   bfd *dynobj;
5707   struct mips_elf_link_hash_entry *hmips;
5708   asection *s;
5709
5710   dynobj = elf_hash_table (info)->dynobj;
5711
5712   /* Make sure we know what is going on here.  */
5713   BFD_ASSERT (dynobj != NULL
5714               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
5715                   || h->weakdef != NULL
5716                   || ((h->elf_link_hash_flags
5717                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5718                       && (h->elf_link_hash_flags
5719                           & ELF_LINK_HASH_REF_REGULAR) != 0
5720                       && (h->elf_link_hash_flags
5721                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
5722
5723   /* If this symbol is defined in a dynamic object, we need to copy
5724      any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5725      file.  */
5726   hmips = (struct mips_elf_link_hash_entry *) h;
5727   if (! info->relocatable
5728       && hmips->possibly_dynamic_relocs != 0
5729       && (h->root.type == bfd_link_hash_defweak
5730           || (h->elf_link_hash_flags
5731               & ELF_LINK_HASH_DEF_REGULAR) == 0))
5732     {
5733       mips_elf_allocate_dynamic_relocations (dynobj,
5734                                              hmips->possibly_dynamic_relocs);
5735       if (hmips->readonly_reloc)
5736         /* We tell the dynamic linker that there are relocations
5737            against the text segment.  */
5738         info->flags |= DF_TEXTREL;
5739     }
5740
5741   /* For a function, create a stub, if allowed.  */
5742   if (! hmips->no_fn_stub
5743       && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
5744     {
5745       if (! elf_hash_table (info)->dynamic_sections_created)
5746         return TRUE;
5747
5748       /* If this symbol is not defined in a regular file, then set
5749          the symbol to the stub location.  This is required to make
5750          function pointers compare as equal between the normal
5751          executable and the shared library.  */
5752       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
5753         {
5754           /* We need .stub section.  */
5755           s = bfd_get_section_by_name (dynobj,
5756                                        MIPS_ELF_STUB_SECTION_NAME (dynobj));
5757           BFD_ASSERT (s != NULL);
5758
5759           h->root.u.def.section = s;
5760           h->root.u.def.value = s->_raw_size;
5761
5762           /* XXX Write this stub address somewhere.  */
5763           h->plt.offset = s->_raw_size;
5764
5765           /* Make room for this stub code.  */
5766           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
5767
5768           /* The last half word of the stub will be filled with the index
5769              of this symbol in .dynsym section.  */
5770           return TRUE;
5771         }
5772     }
5773   else if ((h->type == STT_FUNC)
5774            && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
5775     {
5776       /* This will set the entry for this symbol in the GOT to 0, and
5777          the dynamic linker will take care of this.  */
5778       h->root.u.def.value = 0;
5779       return TRUE;
5780     }
5781
5782   /* If this is a weak symbol, and there is a real definition, the
5783      processor independent code will have arranged for us to see the
5784      real definition first, and we can just use the same value.  */
5785   if (h->weakdef != NULL)
5786     {
5787       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
5788                   || h->weakdef->root.type == bfd_link_hash_defweak);
5789       h->root.u.def.section = h->weakdef->root.u.def.section;
5790       h->root.u.def.value = h->weakdef->root.u.def.value;
5791       return TRUE;
5792     }
5793
5794   /* This is a reference to a symbol defined by a dynamic object which
5795      is not a function.  */
5796
5797   return TRUE;
5798 }
5799 \f
5800 /* This function is called after all the input files have been read,
5801    and the input sections have been assigned to output sections.  We
5802    check for any mips16 stub sections that we can discard.  */
5803
5804 bfd_boolean
5805 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
5806                                     struct bfd_link_info *info)
5807 {
5808   asection *ri;
5809
5810   bfd *dynobj;
5811   asection *s;
5812   struct mips_got_info *g;
5813   int i;
5814   bfd_size_type loadable_size = 0;
5815   bfd_size_type local_gotno;
5816   bfd *sub;
5817
5818   /* The .reginfo section has a fixed size.  */
5819   ri = bfd_get_section_by_name (output_bfd, ".reginfo");
5820   if (ri != NULL)
5821     bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
5822
5823   if (! (info->relocatable
5824          || ! mips_elf_hash_table (info)->mips16_stubs_seen))
5825     mips_elf_link_hash_traverse (mips_elf_hash_table (info),
5826                                  mips_elf_check_mips16_stubs, NULL);
5827
5828   dynobj = elf_hash_table (info)->dynobj;
5829   if (dynobj == NULL)
5830     /* Relocatable links don't have it.  */
5831     return TRUE;
5832
5833   g = mips_elf_got_info (dynobj, &s);
5834   if (s == NULL)
5835     return TRUE;
5836
5837   /* Calculate the total loadable size of the output.  That
5838      will give us the maximum number of GOT_PAGE entries
5839      required.  */
5840   for (sub = info->input_bfds; sub; sub = sub->link_next)
5841     {
5842       asection *subsection;
5843
5844       for (subsection = sub->sections;
5845            subsection;
5846            subsection = subsection->next)
5847         {
5848           if ((subsection->flags & SEC_ALLOC) == 0)
5849             continue;
5850           loadable_size += ((subsection->_raw_size + 0xf)
5851                             &~ (bfd_size_type) 0xf);
5852         }
5853     }
5854
5855   /* There has to be a global GOT entry for every symbol with
5856      a dynamic symbol table index of DT_MIPS_GOTSYM or
5857      higher.  Therefore, it make sense to put those symbols
5858      that need GOT entries at the end of the symbol table.  We
5859      do that here.  */
5860   if (! mips_elf_sort_hash_table (info, 1))
5861     return FALSE;
5862
5863   if (g->global_gotsym != NULL)
5864     i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
5865   else
5866     /* If there are no global symbols, or none requiring
5867        relocations, then GLOBAL_GOTSYM will be NULL.  */
5868     i = 0;
5869
5870   /* In the worst case, we'll get one stub per dynamic symbol, plus
5871      one to account for the dummy entry at the end required by IRIX
5872      rld.  */
5873   loadable_size += MIPS_FUNCTION_STUB_SIZE * (i + 1);
5874
5875   /* Assume there are two loadable segments consisting of
5876      contiguous sections.  Is 5 enough?  */
5877   local_gotno = (loadable_size >> 16) + 5;
5878
5879   g->local_gotno += local_gotno;
5880   s->_raw_size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
5881
5882   g->global_gotno = i;
5883   s->_raw_size += i * MIPS_ELF_GOT_SIZE (output_bfd);
5884
5885   if (s->_raw_size > MIPS_ELF_GOT_MAX_SIZE (output_bfd)
5886       && ! mips_elf_multi_got (output_bfd, info, g, s, local_gotno))
5887     return FALSE;
5888
5889   return TRUE;
5890 }
5891
5892 /* Set the sizes of the dynamic sections.  */
5893
5894 bfd_boolean
5895 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
5896                                      struct bfd_link_info *info)
5897 {
5898   bfd *dynobj;
5899   asection *s;
5900   bfd_boolean reltext;
5901
5902   dynobj = elf_hash_table (info)->dynobj;
5903   BFD_ASSERT (dynobj != NULL);
5904
5905   if (elf_hash_table (info)->dynamic_sections_created)
5906     {
5907       /* Set the contents of the .interp section to the interpreter.  */
5908       if (info->executable)
5909         {
5910           s = bfd_get_section_by_name (dynobj, ".interp");
5911           BFD_ASSERT (s != NULL);
5912           s->_raw_size
5913             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
5914           s->contents
5915             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
5916         }
5917     }
5918
5919   /* The check_relocs and adjust_dynamic_symbol entry points have
5920      determined the sizes of the various dynamic sections.  Allocate
5921      memory for them.  */
5922   reltext = FALSE;
5923   for (s = dynobj->sections; s != NULL; s = s->next)
5924     {
5925       const char *name;
5926       bfd_boolean strip;
5927
5928       /* It's OK to base decisions on the section name, because none
5929          of the dynobj section names depend upon the input files.  */
5930       name = bfd_get_section_name (dynobj, s);
5931
5932       if ((s->flags & SEC_LINKER_CREATED) == 0)
5933         continue;
5934
5935       strip = FALSE;
5936
5937       if (strncmp (name, ".rel", 4) == 0)
5938         {
5939           if (s->_raw_size == 0)
5940             {
5941               /* We only strip the section if the output section name
5942                  has the same name.  Otherwise, there might be several
5943                  input sections for this output section.  FIXME: This
5944                  code is probably not needed these days anyhow, since
5945                  the linker now does not create empty output sections.  */
5946               if (s->output_section != NULL
5947                   && strcmp (name,
5948                              bfd_get_section_name (s->output_section->owner,
5949                                                    s->output_section)) == 0)
5950                 strip = TRUE;
5951             }
5952           else
5953             {
5954               const char *outname;
5955               asection *target;
5956
5957               /* If this relocation section applies to a read only
5958                  section, then we probably need a DT_TEXTREL entry.
5959                  If the relocation section is .rel.dyn, we always
5960                  assert a DT_TEXTREL entry rather than testing whether
5961                  there exists a relocation to a read only section or
5962                  not.  */
5963               outname = bfd_get_section_name (output_bfd,
5964                                               s->output_section);
5965               target = bfd_get_section_by_name (output_bfd, outname + 4);
5966               if ((target != NULL
5967                    && (target->flags & SEC_READONLY) != 0
5968                    && (target->flags & SEC_ALLOC) != 0)
5969                   || strcmp (outname, ".rel.dyn") == 0)
5970                 reltext = TRUE;
5971
5972               /* We use the reloc_count field as a counter if we need
5973                  to copy relocs into the output file.  */
5974               if (strcmp (name, ".rel.dyn") != 0)
5975                 s->reloc_count = 0;
5976
5977               /* If combreloc is enabled, elf_link_sort_relocs() will
5978                  sort relocations, but in a different way than we do,
5979                  and before we're done creating relocations.  Also, it
5980                  will move them around between input sections'
5981                  relocation's contents, so our sorting would be
5982                  broken, so don't let it run.  */
5983               info->combreloc = 0;
5984             }
5985         }
5986       else if (strncmp (name, ".got", 4) == 0)
5987         {
5988           /* _bfd_mips_elf_always_size_sections() has already done
5989              most of the work, but some symbols may have been mapped
5990              to versions that we must now resolve in the got_entries
5991              hash tables.  */
5992           struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
5993           struct mips_got_info *g = gg;
5994           struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
5995           unsigned int needed_relocs = 0;
5996
5997           if (gg->next)
5998             {
5999               set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
6000               set_got_offset_arg.info = info;
6001
6002               mips_elf_resolve_final_got_entries (gg);
6003               for (g = gg->next; g && g->next != gg; g = g->next)
6004                 {
6005                   unsigned int save_assign;
6006
6007                   mips_elf_resolve_final_got_entries (g);
6008
6009                   /* Assign offsets to global GOT entries.  */
6010                   save_assign = g->assigned_gotno;
6011                   g->assigned_gotno = g->local_gotno;
6012                   set_got_offset_arg.g = g;
6013                   set_got_offset_arg.needed_relocs = 0;
6014                   htab_traverse (g->got_entries,
6015                                  mips_elf_set_global_got_offset,
6016                                  &set_got_offset_arg);
6017                   needed_relocs += set_got_offset_arg.needed_relocs;
6018                   BFD_ASSERT (g->assigned_gotno - g->local_gotno
6019                               <= g->global_gotno);
6020
6021                   g->assigned_gotno = save_assign;
6022                   if (info->shared)
6023                     {
6024                       needed_relocs += g->local_gotno - g->assigned_gotno;
6025                       BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
6026                                   + g->next->global_gotno
6027                                   + MIPS_RESERVED_GOTNO);
6028                     }
6029                 }
6030
6031               if (needed_relocs)
6032                 mips_elf_allocate_dynamic_relocations (dynobj, needed_relocs);
6033             }
6034         }
6035       else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
6036         {
6037           /* IRIX rld assumes that the function stub isn't at the end
6038              of .text section. So put a dummy. XXX  */
6039           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
6040         }
6041       else if (! info->shared
6042                && ! mips_elf_hash_table (info)->use_rld_obj_head
6043                && strncmp (name, ".rld_map", 8) == 0)
6044         {
6045           /* We add a room for __rld_map. It will be filled in by the
6046              rtld to contain a pointer to the _r_debug structure.  */
6047           s->_raw_size += 4;
6048         }
6049       else if (SGI_COMPAT (output_bfd)
6050                && strncmp (name, ".compact_rel", 12) == 0)
6051         s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
6052       else if (strncmp (name, ".init", 5) != 0)
6053         {
6054           /* It's not one of our sections, so don't allocate space.  */
6055           continue;
6056         }
6057
6058       if (strip)
6059         {
6060           _bfd_strip_section_from_output (info, s);
6061           continue;
6062         }
6063
6064       /* Allocate memory for the section contents.  */
6065       s->contents = bfd_zalloc (dynobj, s->_raw_size);
6066       if (s->contents == NULL && s->_raw_size != 0)
6067         {
6068           bfd_set_error (bfd_error_no_memory);
6069           return FALSE;
6070         }
6071     }
6072
6073   if (elf_hash_table (info)->dynamic_sections_created)
6074     {
6075       /* Add some entries to the .dynamic section.  We fill in the
6076          values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6077          must add the entries now so that we get the correct size for
6078          the .dynamic section.  The DT_DEBUG entry is filled in by the
6079          dynamic linker and used by the debugger.  */
6080       if (! info->shared)
6081         {
6082           /* SGI object has the equivalence of DT_DEBUG in the
6083              DT_MIPS_RLD_MAP entry.  */
6084           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
6085             return FALSE;
6086           if (!SGI_COMPAT (output_bfd))
6087             {
6088               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6089                 return FALSE;
6090             }
6091         }
6092       else
6093         {
6094           /* Shared libraries on traditional mips have DT_DEBUG.  */
6095           if (!SGI_COMPAT (output_bfd))
6096             {
6097               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6098                 return FALSE;
6099             }
6100         }
6101
6102       if (reltext && SGI_COMPAT (output_bfd))
6103         info->flags |= DF_TEXTREL;
6104
6105       if ((info->flags & DF_TEXTREL) != 0)
6106         {
6107           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
6108             return FALSE;
6109         }
6110
6111       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
6112         return FALSE;
6113
6114       if (mips_elf_rel_dyn_section (dynobj, FALSE))
6115         {
6116           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
6117             return FALSE;
6118
6119           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
6120             return FALSE;
6121
6122           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
6123             return FALSE;
6124         }
6125
6126       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
6127         return FALSE;
6128
6129       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
6130         return FALSE;
6131
6132 #if 0
6133       /* Time stamps in executable files are a bad idea.  */
6134       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
6135         return FALSE;
6136 #endif
6137
6138 #if 0 /* FIXME  */
6139       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
6140         return FALSE;
6141 #endif
6142
6143 #if 0 /* FIXME  */
6144       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
6145         return FALSE;
6146 #endif
6147
6148       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
6149         return FALSE;
6150
6151       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
6152         return FALSE;
6153
6154       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
6155         return FALSE;
6156
6157       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
6158         return FALSE;
6159
6160       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
6161         return FALSE;
6162
6163       if (IRIX_COMPAT (dynobj) == ict_irix5
6164           && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
6165         return FALSE;
6166
6167       if (IRIX_COMPAT (dynobj) == ict_irix6
6168           && (bfd_get_section_by_name
6169               (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
6170           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
6171         return FALSE;
6172     }
6173
6174   return TRUE;
6175 }
6176 \f
6177 /* Relocate a MIPS ELF section.  */
6178
6179 bfd_boolean
6180 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
6181                                 bfd *input_bfd, asection *input_section,
6182                                 bfd_byte *contents, Elf_Internal_Rela *relocs,
6183                                 Elf_Internal_Sym *local_syms,
6184                                 asection **local_sections)
6185 {
6186   Elf_Internal_Rela *rel;
6187   const Elf_Internal_Rela *relend;
6188   bfd_vma addend = 0;
6189   bfd_boolean use_saved_addend_p = FALSE;
6190   const struct elf_backend_data *bed;
6191
6192   bed = get_elf_backend_data (output_bfd);
6193   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6194   for (rel = relocs; rel < relend; ++rel)
6195     {
6196       const char *name;
6197       bfd_vma value;
6198       reloc_howto_type *howto;
6199       bfd_boolean require_jalx;
6200       /* TRUE if the relocation is a RELA relocation, rather than a
6201          REL relocation.  */
6202       bfd_boolean rela_relocation_p = TRUE;
6203       unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6204       const char *msg;
6205
6206       /* Find the relocation howto for this relocation.  */
6207       if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
6208         {
6209           /* Some 32-bit code uses R_MIPS_64.  In particular, people use
6210              64-bit code, but make sure all their addresses are in the
6211              lowermost or uppermost 32-bit section of the 64-bit address
6212              space.  Thus, when they use an R_MIPS_64 they mean what is
6213              usually meant by R_MIPS_32, with the exception that the
6214              stored value is sign-extended to 64 bits.  */
6215           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
6216
6217           /* On big-endian systems, we need to lie about the position
6218              of the reloc.  */
6219           if (bfd_big_endian (input_bfd))
6220             rel->r_offset += 4;
6221         }
6222       else
6223         /* NewABI defaults to RELA relocations.  */
6224         howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
6225                                          NEWABI_P (input_bfd)
6226                                          && (MIPS_RELOC_RELA_P
6227                                              (input_bfd, input_section,
6228                                               rel - relocs)));
6229
6230       if (!use_saved_addend_p)
6231         {
6232           Elf_Internal_Shdr *rel_hdr;
6233
6234           /* If these relocations were originally of the REL variety,
6235              we must pull the addend out of the field that will be
6236              relocated.  Otherwise, we simply use the contents of the
6237              RELA relocation.  To determine which flavor or relocation
6238              this is, we depend on the fact that the INPUT_SECTION's
6239              REL_HDR is read before its REL_HDR2.  */
6240           rel_hdr = &elf_section_data (input_section)->rel_hdr;
6241           if ((size_t) (rel - relocs)
6242               >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6243             rel_hdr = elf_section_data (input_section)->rel_hdr2;
6244           if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6245             {
6246               /* Note that this is a REL relocation.  */
6247               rela_relocation_p = FALSE;
6248
6249               /* Get the addend, which is stored in the input file.  */
6250               addend = mips_elf_obtain_contents (howto, rel, input_bfd,
6251                                                  contents);
6252               addend &= howto->src_mask;
6253
6254               /* For some kinds of relocations, the ADDEND is a
6255                  combination of the addend stored in two different
6256                  relocations.   */
6257               if (r_type == R_MIPS_HI16
6258                   || r_type == R_MIPS_GNU_REL_HI16
6259                   || (r_type == R_MIPS_GOT16
6260                       && mips_elf_local_relocation_p (input_bfd, rel,
6261                                                       local_sections, FALSE)))
6262                 {
6263                   bfd_vma l;
6264                   const Elf_Internal_Rela *lo16_relocation;
6265                   reloc_howto_type *lo16_howto;
6266                   unsigned int lo;
6267
6268                   /* The combined value is the sum of the HI16 addend,
6269                      left-shifted by sixteen bits, and the LO16
6270                      addend, sign extended.  (Usually, the code does
6271                      a `lui' of the HI16 value, and then an `addiu' of
6272                      the LO16 value.)
6273
6274                      Scan ahead to find a matching LO16 relocation.  */
6275                   if (r_type == R_MIPS_GNU_REL_HI16)
6276                     lo = R_MIPS_GNU_REL_LO16;
6277                   else
6278                     lo = R_MIPS_LO16;
6279                   lo16_relocation = mips_elf_next_relocation (input_bfd, lo,
6280                                                               rel, relend);
6281                   if (lo16_relocation == NULL)
6282                     return FALSE;
6283
6284                   /* Obtain the addend kept there.  */
6285                   lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, lo, FALSE);
6286                   l = mips_elf_obtain_contents (lo16_howto, lo16_relocation,
6287                                                 input_bfd, contents);
6288                   l &= lo16_howto->src_mask;
6289                   l <<= lo16_howto->rightshift;
6290                   l = _bfd_mips_elf_sign_extend (l, 16);
6291
6292                   addend <<= 16;
6293
6294                   /* Compute the combined addend.  */
6295                   addend += l;
6296
6297                   /* If PC-relative, subtract the difference between the
6298                      address of the LO part of the reloc and the address of
6299                      the HI part.  The relocation is relative to the LO
6300                      part, but mips_elf_calculate_relocation() doesn't
6301                      know its address or the difference from the HI part, so
6302                      we subtract that difference here.  See also the
6303                      comment in mips_elf_calculate_relocation().  */
6304                   if (r_type == R_MIPS_GNU_REL_HI16)
6305                     addend -= (lo16_relocation->r_offset - rel->r_offset);
6306                 }
6307               else if (r_type == R_MIPS16_GPREL)
6308                 {
6309                   /* The addend is scrambled in the object file.  See
6310                      mips_elf_perform_relocation for details on the
6311                      format.  */
6312                   addend = (((addend & 0x1f0000) >> 5)
6313                             | ((addend & 0x7e00000) >> 16)
6314                             | (addend & 0x1f));
6315                 }
6316               else
6317                 addend <<= howto->rightshift;
6318             }
6319           else
6320             addend = rel->r_addend;
6321         }
6322
6323       if (info->relocatable)
6324         {
6325           Elf_Internal_Sym *sym;
6326           unsigned long r_symndx;
6327
6328           if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
6329               && bfd_big_endian (input_bfd))
6330             rel->r_offset -= 4;
6331
6332           /* Since we're just relocating, all we need to do is copy
6333              the relocations back out to the object file, unless
6334              they're against a section symbol, in which case we need
6335              to adjust by the section offset, or unless they're GP
6336              relative in which case we need to adjust by the amount
6337              that we're adjusting GP in this relocatable object.  */
6338
6339           if (! mips_elf_local_relocation_p (input_bfd, rel, local_sections,
6340                                              FALSE))
6341             /* There's nothing to do for non-local relocations.  */
6342             continue;
6343
6344           if (r_type == R_MIPS16_GPREL
6345               || r_type == R_MIPS_GPREL16
6346               || r_type == R_MIPS_GPREL32
6347               || r_type == R_MIPS_LITERAL)
6348             addend -= (_bfd_get_gp_value (output_bfd)
6349                        - _bfd_get_gp_value (input_bfd));
6350
6351           r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
6352           sym = local_syms + r_symndx;
6353           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6354             /* Adjust the addend appropriately.  */
6355             addend += local_sections[r_symndx]->output_offset;
6356
6357           if (rela_relocation_p)
6358             /* If this is a RELA relocation, just update the addend.  */
6359             rel->r_addend = addend;
6360           else
6361             {
6362               if (r_type == R_MIPS_HI16
6363                   || r_type == R_MIPS_GOT16
6364                   || r_type == R_MIPS_GNU_REL_HI16)
6365                 addend = mips_elf_high (addend);
6366               else if (r_type == R_MIPS_HIGHER)
6367                 addend = mips_elf_higher (addend);
6368               else if (r_type == R_MIPS_HIGHEST)
6369                 addend = mips_elf_highest (addend);
6370               else
6371                 addend >>= howto->rightshift;
6372
6373               /* We use the source mask, rather than the destination
6374                  mask because the place to which we are writing will be
6375                  source of the addend in the final link.  */
6376               addend &= howto->src_mask;
6377
6378               if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6379                 /* See the comment above about using R_MIPS_64 in the 32-bit
6380                    ABI.  Here, we need to update the addend.  It would be
6381                    possible to get away with just using the R_MIPS_32 reloc
6382                    but for endianness.  */
6383                 {
6384                   bfd_vma sign_bits;
6385                   bfd_vma low_bits;
6386                   bfd_vma high_bits;
6387
6388                   if (addend & ((bfd_vma) 1 << 31))
6389 #ifdef BFD64
6390                     sign_bits = ((bfd_vma) 1 << 32) - 1;
6391 #else
6392                     sign_bits = -1;
6393 #endif
6394                   else
6395                     sign_bits = 0;
6396
6397                   /* If we don't know that we have a 64-bit type,
6398                      do two separate stores.  */
6399                   if (bfd_big_endian (input_bfd))
6400                     {
6401                       /* Store the sign-bits (which are most significant)
6402                          first.  */
6403                       low_bits = sign_bits;
6404                       high_bits = addend;
6405                     }
6406                   else
6407                     {
6408                       low_bits = addend;
6409                       high_bits = sign_bits;
6410                     }
6411                   bfd_put_32 (input_bfd, low_bits,
6412                               contents + rel->r_offset);
6413                   bfd_put_32 (input_bfd, high_bits,
6414                               contents + rel->r_offset + 4);
6415                   continue;
6416                 }
6417
6418               if (! mips_elf_perform_relocation (info, howto, rel, addend,
6419                                                  input_bfd, input_section,
6420                                                  contents, FALSE))
6421                 return FALSE;
6422             }
6423
6424           /* Go on to the next relocation.  */
6425           continue;
6426         }
6427
6428       /* In the N32 and 64-bit ABIs there may be multiple consecutive
6429          relocations for the same offset.  In that case we are
6430          supposed to treat the output of each relocation as the addend
6431          for the next.  */
6432       if (rel + 1 < relend
6433           && rel->r_offset == rel[1].r_offset
6434           && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
6435         use_saved_addend_p = TRUE;
6436       else
6437         use_saved_addend_p = FALSE;
6438
6439       /* Figure out what value we are supposed to relocate.  */
6440       switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
6441                                              input_section, info, rel,
6442                                              addend, howto, local_syms,
6443                                              local_sections, &value,
6444                                              &name, &require_jalx,
6445                                              use_saved_addend_p))
6446         {
6447         case bfd_reloc_continue:
6448           /* There's nothing to do.  */
6449           continue;
6450
6451         case bfd_reloc_undefined:
6452           /* mips_elf_calculate_relocation already called the
6453              undefined_symbol callback.  There's no real point in
6454              trying to perform the relocation at this point, so we
6455              just skip ahead to the next relocation.  */
6456           continue;
6457
6458         case bfd_reloc_notsupported:
6459           msg = _("internal error: unsupported relocation error");
6460           info->callbacks->warning
6461             (info, msg, name, input_bfd, input_section, rel->r_offset);
6462           return FALSE;
6463
6464         case bfd_reloc_overflow:
6465           if (use_saved_addend_p)
6466             /* Ignore overflow until we reach the last relocation for
6467                a given location.  */
6468             ;
6469           else
6470             {
6471               BFD_ASSERT (name != NULL);
6472               if (! ((*info->callbacks->reloc_overflow)
6473                      (info, name, howto->name, 0,
6474                       input_bfd, input_section, rel->r_offset)))
6475                 return FALSE;
6476             }
6477           break;
6478
6479         case bfd_reloc_ok:
6480           break;
6481
6482         default:
6483           abort ();
6484           break;
6485         }
6486
6487       /* If we've got another relocation for the address, keep going
6488          until we reach the last one.  */
6489       if (use_saved_addend_p)
6490         {
6491           addend = value;
6492           continue;
6493         }
6494
6495       if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6496         /* See the comment above about using R_MIPS_64 in the 32-bit
6497            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
6498            that calculated the right value.  Now, however, we
6499            sign-extend the 32-bit result to 64-bits, and store it as a
6500            64-bit value.  We are especially generous here in that we
6501            go to extreme lengths to support this usage on systems with
6502            only a 32-bit VMA.  */
6503         {
6504           bfd_vma sign_bits;
6505           bfd_vma low_bits;
6506           bfd_vma high_bits;
6507
6508           if (value & ((bfd_vma) 1 << 31))
6509 #ifdef BFD64
6510             sign_bits = ((bfd_vma) 1 << 32) - 1;
6511 #else
6512             sign_bits = -1;
6513 #endif
6514           else
6515             sign_bits = 0;
6516
6517           /* If we don't know that we have a 64-bit type,
6518              do two separate stores.  */
6519           if (bfd_big_endian (input_bfd))
6520             {
6521               /* Undo what we did above.  */
6522               rel->r_offset -= 4;
6523               /* Store the sign-bits (which are most significant)
6524                  first.  */
6525               low_bits = sign_bits;
6526               high_bits = value;
6527             }
6528           else
6529             {
6530               low_bits = value;
6531               high_bits = sign_bits;
6532             }
6533           bfd_put_32 (input_bfd, low_bits,
6534                       contents + rel->r_offset);
6535           bfd_put_32 (input_bfd, high_bits,
6536                       contents + rel->r_offset + 4);
6537           continue;
6538         }
6539
6540       /* Actually perform the relocation.  */
6541       if (! mips_elf_perform_relocation (info, howto, rel, value,
6542                                          input_bfd, input_section,
6543                                          contents, require_jalx))
6544         return FALSE;
6545     }
6546
6547   return TRUE;
6548 }
6549 \f
6550 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6551    adjust it appropriately now.  */
6552
6553 static void
6554 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
6555                                       const char *name, Elf_Internal_Sym *sym)
6556 {
6557   /* The linker script takes care of providing names and values for
6558      these, but we must place them into the right sections.  */
6559   static const char* const text_section_symbols[] = {
6560     "_ftext",
6561     "_etext",
6562     "__dso_displacement",
6563     "__elf_header",
6564     "__program_header_table",
6565     NULL
6566   };
6567
6568   static const char* const data_section_symbols[] = {
6569     "_fdata",
6570     "_edata",
6571     "_end",
6572     "_fbss",
6573     NULL
6574   };
6575
6576   const char* const *p;
6577   int i;
6578
6579   for (i = 0; i < 2; ++i)
6580     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
6581          *p;
6582          ++p)
6583       if (strcmp (*p, name) == 0)
6584         {
6585           /* All of these symbols are given type STT_SECTION by the
6586              IRIX6 linker.  */
6587           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6588           sym->st_other = STO_PROTECTED;
6589
6590           /* The IRIX linker puts these symbols in special sections.  */
6591           if (i == 0)
6592             sym->st_shndx = SHN_MIPS_TEXT;
6593           else
6594             sym->st_shndx = SHN_MIPS_DATA;
6595
6596           break;
6597         }
6598 }
6599
6600 /* Finish up dynamic symbol handling.  We set the contents of various
6601    dynamic sections here.  */
6602
6603 bfd_boolean
6604 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
6605                                      struct bfd_link_info *info,
6606                                      struct elf_link_hash_entry *h,
6607                                      Elf_Internal_Sym *sym)
6608 {
6609   bfd *dynobj;
6610   bfd_vma gval;
6611   asection *sgot;
6612   struct mips_got_info *g, *gg;
6613   const char *name;
6614
6615   dynobj = elf_hash_table (info)->dynobj;
6616   gval = sym->st_value;
6617
6618   if (h->plt.offset != (bfd_vma) -1)
6619     {
6620       asection *s;
6621       bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
6622
6623       /* This symbol has a stub.  Set it up.  */
6624
6625       BFD_ASSERT (h->dynindx != -1);
6626
6627       s = bfd_get_section_by_name (dynobj,
6628                                    MIPS_ELF_STUB_SECTION_NAME (dynobj));
6629       BFD_ASSERT (s != NULL);
6630
6631       /* FIXME: Can h->dynindex be more than 64K?  */
6632       if (h->dynindx & 0xffff0000)
6633         return FALSE;
6634
6635       /* Fill the stub.  */
6636       bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub);
6637       bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + 4);
6638       bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
6639       bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, stub + 12);
6640
6641       BFD_ASSERT (h->plt.offset <= s->_raw_size);
6642       memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
6643
6644       /* Mark the symbol as undefined.  plt.offset != -1 occurs
6645          only for the referenced symbol.  */
6646       sym->st_shndx = SHN_UNDEF;
6647
6648       /* The run-time linker uses the st_value field of the symbol
6649          to reset the global offset table entry for this external
6650          to its stub address when unlinking a shared object.  */
6651       gval = s->output_section->vma + s->output_offset + h->plt.offset;
6652       sym->st_value = gval;
6653     }
6654
6655   BFD_ASSERT (h->dynindx != -1
6656               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
6657
6658   sgot = mips_elf_got_section (dynobj, FALSE);
6659   BFD_ASSERT (sgot != NULL);
6660   BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6661   g = mips_elf_section_data (sgot)->u.got_info;
6662   BFD_ASSERT (g != NULL);
6663
6664   /* Run through the global symbol table, creating GOT entries for all
6665      the symbols that need them.  */
6666   if (g->global_gotsym != NULL
6667       && h->dynindx >= g->global_gotsym->dynindx)
6668     {
6669       bfd_vma offset;
6670       bfd_vma value;
6671
6672       value = sym->st_value;
6673       offset = mips_elf_global_got_index (dynobj, output_bfd, h);
6674       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6675     }
6676
6677   if (g->next && h->dynindx != -1)
6678     {
6679       struct mips_got_entry e, *p;
6680       bfd_vma entry;
6681       bfd_vma offset;
6682
6683       gg = g;
6684
6685       e.abfd = output_bfd;
6686       e.symndx = -1;
6687       e.d.h = (struct mips_elf_link_hash_entry *)h;
6688
6689       for (g = g->next; g->next != gg; g = g->next)
6690         {
6691           if (g->got_entries
6692               && (p = (struct mips_got_entry *) htab_find (g->got_entries,
6693                                                            &e)))
6694             {
6695               offset = p->gotidx;
6696               if (info->shared
6697                   || (elf_hash_table (info)->dynamic_sections_created
6698                       && p->d.h != NULL
6699                       && ((p->d.h->root.elf_link_hash_flags
6700                            & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
6701                       && ((p->d.h->root.elf_link_hash_flags
6702                            & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6703                 {
6704                   /* Create an R_MIPS_REL32 relocation for this entry.  Due to
6705                      the various compatibility problems, it's easier to mock
6706                      up an R_MIPS_32 or R_MIPS_64 relocation and leave
6707                      mips_elf_create_dynamic_relocation to calculate the
6708                      appropriate addend.  */
6709                   Elf_Internal_Rela rel[3];
6710
6711                   memset (rel, 0, sizeof (rel));
6712                   if (ABI_64_P (output_bfd))
6713                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
6714                   else
6715                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
6716                   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
6717
6718                   entry = 0;
6719                   if (! (mips_elf_create_dynamic_relocation
6720                          (output_bfd, info, rel,
6721                           e.d.h, NULL, sym->st_value, &entry, sgot)))
6722                     return FALSE;
6723                 }
6724               else
6725                 entry = sym->st_value;
6726               MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
6727             }
6728         }
6729     }
6730
6731   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
6732   name = h->root.root.string;
6733   if (strcmp (name, "_DYNAMIC") == 0
6734       || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
6735     sym->st_shndx = SHN_ABS;
6736   else if (strcmp (name, "_DYNAMIC_LINK") == 0
6737            || strcmp (name, "_DYNAMIC_LINKING") == 0)
6738     {
6739       sym->st_shndx = SHN_ABS;
6740       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6741       sym->st_value = 1;
6742     }
6743   else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
6744     {
6745       sym->st_shndx = SHN_ABS;
6746       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6747       sym->st_value = elf_gp (output_bfd);
6748     }
6749   else if (SGI_COMPAT (output_bfd))
6750     {
6751       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
6752           || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
6753         {
6754           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6755           sym->st_other = STO_PROTECTED;
6756           sym->st_value = 0;
6757           sym->st_shndx = SHN_MIPS_DATA;
6758         }
6759       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
6760         {
6761           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6762           sym->st_other = STO_PROTECTED;
6763           sym->st_value = mips_elf_hash_table (info)->procedure_count;
6764           sym->st_shndx = SHN_ABS;
6765         }
6766       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
6767         {
6768           if (h->type == STT_FUNC)
6769             sym->st_shndx = SHN_MIPS_TEXT;
6770           else if (h->type == STT_OBJECT)
6771             sym->st_shndx = SHN_MIPS_DATA;
6772         }
6773     }
6774
6775   /* Handle the IRIX6-specific symbols.  */
6776   if (IRIX_COMPAT (output_bfd) == ict_irix6)
6777     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
6778
6779   if (! info->shared)
6780     {
6781       if (! mips_elf_hash_table (info)->use_rld_obj_head
6782           && (strcmp (name, "__rld_map") == 0
6783               || strcmp (name, "__RLD_MAP") == 0))
6784         {
6785           asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
6786           BFD_ASSERT (s != NULL);
6787           sym->st_value = s->output_section->vma + s->output_offset;
6788           bfd_put_32 (output_bfd, 0, s->contents);
6789           if (mips_elf_hash_table (info)->rld_value == 0)
6790             mips_elf_hash_table (info)->rld_value = sym->st_value;
6791         }
6792       else if (mips_elf_hash_table (info)->use_rld_obj_head
6793                && strcmp (name, "__rld_obj_head") == 0)
6794         {
6795           /* IRIX6 does not use a .rld_map section.  */
6796           if (IRIX_COMPAT (output_bfd) == ict_irix5
6797               || IRIX_COMPAT (output_bfd) == ict_none)
6798             BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
6799                         != NULL);
6800           mips_elf_hash_table (info)->rld_value = sym->st_value;
6801         }
6802     }
6803
6804   /* If this is a mips16 symbol, force the value to be even.  */
6805   if (sym->st_other == STO_MIPS16
6806       && (sym->st_value & 1) != 0)
6807     --sym->st_value;
6808
6809   return TRUE;
6810 }
6811
6812 /* Finish up the dynamic sections.  */
6813
6814 bfd_boolean
6815 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
6816                                        struct bfd_link_info *info)
6817 {
6818   bfd *dynobj;
6819   asection *sdyn;
6820   asection *sgot;
6821   struct mips_got_info *gg, *g;
6822
6823   dynobj = elf_hash_table (info)->dynobj;
6824
6825   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6826
6827   sgot = mips_elf_got_section (dynobj, FALSE);
6828   if (sgot == NULL)
6829     gg = g = NULL;
6830   else
6831     {
6832       BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6833       gg = mips_elf_section_data (sgot)->u.got_info;
6834       BFD_ASSERT (gg != NULL);
6835       g = mips_elf_got_for_ibfd (gg, output_bfd);
6836       BFD_ASSERT (g != NULL);
6837     }
6838
6839   if (elf_hash_table (info)->dynamic_sections_created)
6840     {
6841       bfd_byte *b;
6842
6843       BFD_ASSERT (sdyn != NULL);
6844       BFD_ASSERT (g != NULL);
6845
6846       for (b = sdyn->contents;
6847            b < sdyn->contents + sdyn->_raw_size;
6848            b += MIPS_ELF_DYN_SIZE (dynobj))
6849         {
6850           Elf_Internal_Dyn dyn;
6851           const char *name;
6852           size_t elemsize;
6853           asection *s;
6854           bfd_boolean swap_out_p;
6855
6856           /* Read in the current dynamic entry.  */
6857           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
6858
6859           /* Assume that we're going to modify it and write it out.  */
6860           swap_out_p = TRUE;
6861
6862           switch (dyn.d_tag)
6863             {
6864             case DT_RELENT:
6865               s = mips_elf_rel_dyn_section (dynobj, FALSE);
6866               BFD_ASSERT (s != NULL);
6867               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
6868               break;
6869
6870             case DT_STRSZ:
6871               /* Rewrite DT_STRSZ.  */
6872               dyn.d_un.d_val =
6873                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6874               break;
6875
6876             case DT_PLTGOT:
6877               name = ".got";
6878               s = bfd_get_section_by_name (output_bfd, name);
6879               BFD_ASSERT (s != NULL);
6880               dyn.d_un.d_ptr = s->vma;
6881               break;
6882
6883             case DT_MIPS_RLD_VERSION:
6884               dyn.d_un.d_val = 1; /* XXX */
6885               break;
6886
6887             case DT_MIPS_FLAGS:
6888               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
6889               break;
6890
6891             case DT_MIPS_TIME_STAMP:
6892               time ((time_t *) &dyn.d_un.d_val);
6893               break;
6894
6895             case DT_MIPS_ICHECKSUM:
6896               /* XXX FIXME: */
6897               swap_out_p = FALSE;
6898               break;
6899
6900             case DT_MIPS_IVERSION:
6901               /* XXX FIXME: */
6902               swap_out_p = FALSE;
6903               break;
6904
6905             case DT_MIPS_BASE_ADDRESS:
6906               s = output_bfd->sections;
6907               BFD_ASSERT (s != NULL);
6908               dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
6909               break;
6910
6911             case DT_MIPS_LOCAL_GOTNO:
6912               dyn.d_un.d_val = g->local_gotno;
6913               break;
6914
6915             case DT_MIPS_UNREFEXTNO:
6916               /* The index into the dynamic symbol table which is the
6917                  entry of the first external symbol that is not
6918                  referenced within the same object.  */
6919               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
6920               break;
6921
6922             case DT_MIPS_GOTSYM:
6923               if (gg->global_gotsym)
6924                 {
6925                   dyn.d_un.d_val = gg->global_gotsym->dynindx;
6926                   break;
6927                 }
6928               /* In case if we don't have global got symbols we default
6929                  to setting DT_MIPS_GOTSYM to the same value as
6930                  DT_MIPS_SYMTABNO, so we just fall through.  */
6931
6932             case DT_MIPS_SYMTABNO:
6933               name = ".dynsym";
6934               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
6935               s = bfd_get_section_by_name (output_bfd, name);
6936               BFD_ASSERT (s != NULL);
6937
6938               if (s->_cooked_size != 0)
6939                 dyn.d_un.d_val = s->_cooked_size / elemsize;
6940               else
6941                 dyn.d_un.d_val = s->_raw_size / elemsize;
6942               break;
6943
6944             case DT_MIPS_HIPAGENO:
6945               dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
6946               break;
6947
6948             case DT_MIPS_RLD_MAP:
6949               dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
6950               break;
6951
6952             case DT_MIPS_OPTIONS:
6953               s = (bfd_get_section_by_name
6954                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
6955               dyn.d_un.d_ptr = s->vma;
6956               break;
6957
6958             case DT_RELSZ:
6959               /* Reduce DT_RELSZ to account for any relocations we
6960                  decided not to make.  This is for the n64 irix rld,
6961                  which doesn't seem to apply any relocations if there
6962                  are trailing null entries.  */
6963               s = mips_elf_rel_dyn_section (dynobj, FALSE);
6964               dyn.d_un.d_val = (s->reloc_count
6965                                 * (ABI_64_P (output_bfd)
6966                                    ? sizeof (Elf64_Mips_External_Rel)
6967                                    : sizeof (Elf32_External_Rel)));
6968               break;
6969
6970             default:
6971               swap_out_p = FALSE;
6972               break;
6973             }
6974
6975           if (swap_out_p)
6976             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
6977               (dynobj, &dyn, b);
6978         }
6979     }
6980
6981   /* The first entry of the global offset table will be filled at
6982      runtime. The second entry will be used by some runtime loaders.
6983      This isn't the case of IRIX rld.  */
6984   if (sgot != NULL && sgot->_raw_size > 0)
6985     {
6986       MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents);
6987       MIPS_ELF_PUT_WORD (output_bfd, 0x80000000,
6988                          sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
6989     }
6990
6991   if (sgot != NULL)
6992     elf_section_data (sgot->output_section)->this_hdr.sh_entsize
6993       = MIPS_ELF_GOT_SIZE (output_bfd);
6994
6995   /* Generate dynamic relocations for the non-primary gots.  */
6996   if (gg != NULL && gg->next)
6997     {
6998       Elf_Internal_Rela rel[3];
6999       bfd_vma addend = 0;
7000
7001       memset (rel, 0, sizeof (rel));
7002       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
7003
7004       for (g = gg->next; g->next != gg; g = g->next)
7005         {
7006           bfd_vma index = g->next->local_gotno + g->next->global_gotno;
7007
7008           MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
7009                              + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7010           MIPS_ELF_PUT_WORD (output_bfd, 0x80000000, sgot->contents
7011                              + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7012
7013           if (! info->shared)
7014             continue;
7015
7016           while (index < g->assigned_gotno)
7017             {
7018               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
7019                 = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
7020               if (!(mips_elf_create_dynamic_relocation
7021                     (output_bfd, info, rel, NULL,
7022                      bfd_abs_section_ptr,
7023                      0, &addend, sgot)))
7024                 return FALSE;
7025               BFD_ASSERT (addend == 0);
7026             }
7027         }
7028     }
7029
7030   {
7031     asection *s;
7032     Elf32_compact_rel cpt;
7033
7034     if (SGI_COMPAT (output_bfd))
7035       {
7036         /* Write .compact_rel section out.  */
7037         s = bfd_get_section_by_name (dynobj, ".compact_rel");
7038         if (s != NULL)
7039           {
7040             cpt.id1 = 1;
7041             cpt.num = s->reloc_count;
7042             cpt.id2 = 2;
7043             cpt.offset = (s->output_section->filepos
7044                           + sizeof (Elf32_External_compact_rel));
7045             cpt.reserved0 = 0;
7046             cpt.reserved1 = 0;
7047             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
7048                                             ((Elf32_External_compact_rel *)
7049                                              s->contents));
7050
7051             /* Clean up a dummy stub function entry in .text.  */
7052             s = bfd_get_section_by_name (dynobj,
7053                                          MIPS_ELF_STUB_SECTION_NAME (dynobj));
7054             if (s != NULL)
7055               {
7056                 file_ptr dummy_offset;
7057
7058                 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
7059                 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
7060                 memset (s->contents + dummy_offset, 0,
7061                         MIPS_FUNCTION_STUB_SIZE);
7062               }
7063           }
7064       }
7065
7066     /* We need to sort the entries of the dynamic relocation section.  */
7067
7068     s = mips_elf_rel_dyn_section (dynobj, FALSE);
7069
7070     if (s != NULL
7071         && s->_raw_size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
7072       {
7073         reldyn_sorting_bfd = output_bfd;
7074
7075         if (ABI_64_P (output_bfd))
7076           qsort ((Elf64_External_Rel *) s->contents + 1, s->reloc_count - 1,
7077                  sizeof (Elf64_Mips_External_Rel), sort_dynamic_relocs_64);
7078         else
7079           qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1,
7080                  sizeof (Elf32_External_Rel), sort_dynamic_relocs);
7081       }
7082   }
7083
7084   return TRUE;
7085 }
7086
7087
7088 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
7089
7090 static void
7091 mips_set_isa_flags (bfd *abfd)
7092 {
7093   flagword val;
7094
7095   switch (bfd_get_mach (abfd))
7096     {
7097     default:
7098     case bfd_mach_mips3000:
7099       val = E_MIPS_ARCH_1;
7100       break;
7101
7102     case bfd_mach_mips3900:
7103       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
7104       break;
7105
7106     case bfd_mach_mips6000:
7107       val = E_MIPS_ARCH_2;
7108       break;
7109
7110     case bfd_mach_mips4000:
7111     case bfd_mach_mips4300:
7112     case bfd_mach_mips4400:
7113     case bfd_mach_mips4600:
7114       val = E_MIPS_ARCH_3;
7115       break;
7116
7117     case bfd_mach_mips4010:
7118       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
7119       break;
7120
7121     case bfd_mach_mips4100:
7122       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
7123       break;
7124
7125     case bfd_mach_mips4111:
7126       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
7127       break;
7128
7129     case bfd_mach_mips4120:
7130       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
7131       break;
7132
7133     case bfd_mach_mips4650:
7134       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
7135       break;
7136
7137     case bfd_mach_mips5400:
7138       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
7139       break;
7140
7141     case bfd_mach_mips5500:
7142       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
7143       break;
7144
7145     case bfd_mach_mips5000:
7146     case bfd_mach_mips7000:
7147     case bfd_mach_mips8000:
7148     case bfd_mach_mips10000:
7149     case bfd_mach_mips12000:
7150       val = E_MIPS_ARCH_4;
7151       break;
7152
7153     case bfd_mach_mips5:
7154       val = E_MIPS_ARCH_5;
7155       break;
7156
7157     case bfd_mach_mips_sb1:
7158       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
7159       break;
7160
7161     case bfd_mach_mipsisa32:
7162       val = E_MIPS_ARCH_32;
7163       break;
7164
7165     case bfd_mach_mipsisa64:
7166       val = E_MIPS_ARCH_64;
7167       break;
7168
7169     case bfd_mach_mipsisa32r2:
7170       val = E_MIPS_ARCH_32R2;
7171       break;
7172
7173     case bfd_mach_mipsisa64r2:
7174       val = E_MIPS_ARCH_64R2;
7175       break;
7176     }
7177   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
7178   elf_elfheader (abfd)->e_flags |= val;
7179
7180 }
7181
7182
7183 /* The final processing done just before writing out a MIPS ELF object
7184    file.  This gets the MIPS architecture right based on the machine
7185    number.  This is used by both the 32-bit and the 64-bit ABI.  */
7186
7187 void
7188 _bfd_mips_elf_final_write_processing (bfd *abfd,
7189                                       bfd_boolean linker ATTRIBUTE_UNUSED)
7190 {
7191   unsigned int i;
7192   Elf_Internal_Shdr **hdrpp;
7193   const char *name;
7194   asection *sec;
7195
7196   /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7197      is nonzero.  This is for compatibility with old objects, which used
7198      a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
7199   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
7200     mips_set_isa_flags (abfd);
7201
7202   /* Set the sh_info field for .gptab sections and other appropriate
7203      info for each special section.  */
7204   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
7205        i < elf_numsections (abfd);
7206        i++, hdrpp++)
7207     {
7208       switch ((*hdrpp)->sh_type)
7209         {
7210         case SHT_MIPS_MSYM:
7211         case SHT_MIPS_LIBLIST:
7212           sec = bfd_get_section_by_name (abfd, ".dynstr");
7213           if (sec != NULL)
7214             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7215           break;
7216
7217         case SHT_MIPS_GPTAB:
7218           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7219           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7220           BFD_ASSERT (name != NULL
7221                       && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
7222           sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
7223           BFD_ASSERT (sec != NULL);
7224           (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7225           break;
7226
7227         case SHT_MIPS_CONTENT:
7228           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7229           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7230           BFD_ASSERT (name != NULL
7231                       && strncmp (name, ".MIPS.content",
7232                                   sizeof ".MIPS.content" - 1) == 0);
7233           sec = bfd_get_section_by_name (abfd,
7234                                          name + sizeof ".MIPS.content" - 1);
7235           BFD_ASSERT (sec != NULL);
7236           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7237           break;
7238
7239         case SHT_MIPS_SYMBOL_LIB:
7240           sec = bfd_get_section_by_name (abfd, ".dynsym");
7241           if (sec != NULL)
7242             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7243           sec = bfd_get_section_by_name (abfd, ".liblist");
7244           if (sec != NULL)
7245             (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7246           break;
7247
7248         case SHT_MIPS_EVENTS:
7249           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7250           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7251           BFD_ASSERT (name != NULL);
7252           if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7253             sec = bfd_get_section_by_name (abfd,
7254                                            name + sizeof ".MIPS.events" - 1);
7255           else
7256             {
7257               BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
7258                                    sizeof ".MIPS.post_rel" - 1) == 0);
7259               sec = bfd_get_section_by_name (abfd,
7260                                              (name
7261                                               + sizeof ".MIPS.post_rel" - 1));
7262             }
7263           BFD_ASSERT (sec != NULL);
7264           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7265           break;
7266
7267         }
7268     }
7269 }
7270 \f
7271 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7272    segments.  */
7273
7274 int
7275 _bfd_mips_elf_additional_program_headers (bfd *abfd)
7276 {
7277   asection *s;
7278   int ret = 0;
7279
7280   /* See if we need a PT_MIPS_REGINFO segment.  */
7281   s = bfd_get_section_by_name (abfd, ".reginfo");
7282   if (s && (s->flags & SEC_LOAD))
7283     ++ret;
7284
7285   /* See if we need a PT_MIPS_OPTIONS segment.  */
7286   if (IRIX_COMPAT (abfd) == ict_irix6
7287       && bfd_get_section_by_name (abfd,
7288                                   MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
7289     ++ret;
7290
7291   /* See if we need a PT_MIPS_RTPROC segment.  */
7292   if (IRIX_COMPAT (abfd) == ict_irix5
7293       && bfd_get_section_by_name (abfd, ".dynamic")
7294       && bfd_get_section_by_name (abfd, ".mdebug"))
7295     ++ret;
7296
7297   return ret;
7298 }
7299
7300 /* Modify the segment map for an IRIX5 executable.  */
7301
7302 bfd_boolean
7303 _bfd_mips_elf_modify_segment_map (bfd *abfd,
7304                                   struct bfd_link_info *info ATTRIBUTE_UNUSED)
7305 {
7306   asection *s;
7307   struct elf_segment_map *m, **pm;
7308   bfd_size_type amt;
7309
7310   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7311      segment.  */
7312   s = bfd_get_section_by_name (abfd, ".reginfo");
7313   if (s != NULL && (s->flags & SEC_LOAD) != 0)
7314     {
7315       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7316         if (m->p_type == PT_MIPS_REGINFO)
7317           break;
7318       if (m == NULL)
7319         {
7320           amt = sizeof *m;
7321           m = bfd_zalloc (abfd, amt);
7322           if (m == NULL)
7323             return FALSE;
7324
7325           m->p_type = PT_MIPS_REGINFO;
7326           m->count = 1;
7327           m->sections[0] = s;
7328
7329           /* We want to put it after the PHDR and INTERP segments.  */
7330           pm = &elf_tdata (abfd)->segment_map;
7331           while (*pm != NULL
7332                  && ((*pm)->p_type == PT_PHDR
7333                      || (*pm)->p_type == PT_INTERP))
7334             pm = &(*pm)->next;
7335
7336           m->next = *pm;
7337           *pm = m;
7338         }
7339     }
7340
7341   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7342      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
7343      PT_MIPS_OPTIONS segment immediately following the program header
7344      table.  */
7345   if (NEWABI_P (abfd)
7346       /* On non-IRIX6 new abi, we'll have already created a segment
7347          for this section, so don't create another.  I'm not sure this
7348          is not also the case for IRIX 6, but I can't test it right
7349          now.  */
7350       && IRIX_COMPAT (abfd) == ict_irix6)
7351     {
7352       for (s = abfd->sections; s; s = s->next)
7353         if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
7354           break;
7355
7356       if (s)
7357         {
7358           struct elf_segment_map *options_segment;
7359
7360           pm = &elf_tdata (abfd)->segment_map;
7361           while (*pm != NULL
7362                  && ((*pm)->p_type == PT_PHDR
7363                      || (*pm)->p_type == PT_INTERP))
7364             pm = &(*pm)->next;
7365
7366           amt = sizeof (struct elf_segment_map);
7367           options_segment = bfd_zalloc (abfd, amt);
7368           options_segment->next = *pm;
7369           options_segment->p_type = PT_MIPS_OPTIONS;
7370           options_segment->p_flags = PF_R;
7371           options_segment->p_flags_valid = TRUE;
7372           options_segment->count = 1;
7373           options_segment->sections[0] = s;
7374           *pm = options_segment;
7375         }
7376     }
7377   else
7378     {
7379       if (IRIX_COMPAT (abfd) == ict_irix5)
7380         {
7381           /* If there are .dynamic and .mdebug sections, we make a room
7382              for the RTPROC header.  FIXME: Rewrite without section names.  */
7383           if (bfd_get_section_by_name (abfd, ".interp") == NULL
7384               && bfd_get_section_by_name (abfd, ".dynamic") != NULL
7385               && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
7386             {
7387               for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7388                 if (m->p_type == PT_MIPS_RTPROC)
7389                   break;
7390               if (m == NULL)
7391                 {
7392                   amt = sizeof *m;
7393                   m = bfd_zalloc (abfd, amt);
7394                   if (m == NULL)
7395                     return FALSE;
7396
7397                   m->p_type = PT_MIPS_RTPROC;
7398
7399                   s = bfd_get_section_by_name (abfd, ".rtproc");
7400                   if (s == NULL)
7401                     {
7402                       m->count = 0;
7403                       m->p_flags = 0;
7404                       m->p_flags_valid = 1;
7405                     }
7406                   else
7407                     {
7408                       m->count = 1;
7409                       m->sections[0] = s;
7410                     }
7411
7412                   /* We want to put it after the DYNAMIC segment.  */
7413                   pm = &elf_tdata (abfd)->segment_map;
7414                   while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
7415                     pm = &(*pm)->next;
7416                   if (*pm != NULL)
7417                     pm = &(*pm)->next;
7418
7419                   m->next = *pm;
7420                   *pm = m;
7421                 }
7422             }
7423         }
7424       /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7425          .dynstr, .dynsym, and .hash sections, and everything in
7426          between.  */
7427       for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
7428            pm = &(*pm)->next)
7429         if ((*pm)->p_type == PT_DYNAMIC)
7430           break;
7431       m = *pm;
7432       if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
7433         {
7434           /* For a normal mips executable the permissions for the PT_DYNAMIC
7435              segment are read, write and execute. We do that here since
7436              the code in elf.c sets only the read permission. This matters
7437              sometimes for the dynamic linker.  */
7438           if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
7439             {
7440               m->p_flags = PF_R | PF_W | PF_X;
7441               m->p_flags_valid = 1;
7442             }
7443         }
7444       if (m != NULL
7445           && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
7446         {
7447           static const char *sec_names[] =
7448           {
7449             ".dynamic", ".dynstr", ".dynsym", ".hash"
7450           };
7451           bfd_vma low, high;
7452           unsigned int i, c;
7453           struct elf_segment_map *n;
7454
7455           low = ~(bfd_vma) 0;
7456           high = 0;
7457           for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
7458             {
7459               s = bfd_get_section_by_name (abfd, sec_names[i]);
7460               if (s != NULL && (s->flags & SEC_LOAD) != 0)
7461                 {
7462                   bfd_size_type sz;
7463
7464                   if (low > s->vma)
7465                     low = s->vma;
7466                   sz = s->_cooked_size;
7467                   if (sz == 0)
7468                     sz = s->_raw_size;
7469                   if (high < s->vma + sz)
7470                     high = s->vma + sz;
7471                 }
7472             }
7473
7474           c = 0;
7475           for (s = abfd->sections; s != NULL; s = s->next)
7476             if ((s->flags & SEC_LOAD) != 0
7477                 && s->vma >= low
7478                 && ((s->vma
7479                      + (s->_cooked_size !=
7480                         0 ? s->_cooked_size : s->_raw_size)) <= high))
7481               ++c;
7482
7483           amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
7484           n = bfd_zalloc (abfd, amt);
7485           if (n == NULL)
7486             return FALSE;
7487           *n = *m;
7488           n->count = c;
7489
7490           i = 0;
7491           for (s = abfd->sections; s != NULL; s = s->next)
7492             {
7493               if ((s->flags & SEC_LOAD) != 0
7494                   && s->vma >= low
7495                   && ((s->vma
7496                        + (s->_cooked_size != 0 ?
7497                           s->_cooked_size : s->_raw_size)) <= high))
7498                 {
7499                   n->sections[i] = s;
7500                   ++i;
7501                 }
7502             }
7503
7504           *pm = n;
7505         }
7506     }
7507
7508   return TRUE;
7509 }
7510 \f
7511 /* Return the section that should be marked against GC for a given
7512    relocation.  */
7513
7514 asection *
7515 _bfd_mips_elf_gc_mark_hook (asection *sec,
7516                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
7517                             Elf_Internal_Rela *rel,
7518                             struct elf_link_hash_entry *h,
7519                             Elf_Internal_Sym *sym)
7520 {
7521   /* ??? Do mips16 stub sections need to be handled special?  */
7522
7523   if (h != NULL)
7524     {
7525       switch (ELF_R_TYPE (sec->owner, rel->r_info))
7526         {
7527         case R_MIPS_GNU_VTINHERIT:
7528         case R_MIPS_GNU_VTENTRY:
7529           break;
7530
7531         default:
7532           switch (h->root.type)
7533             {
7534             case bfd_link_hash_defined:
7535             case bfd_link_hash_defweak:
7536               return h->root.u.def.section;
7537
7538             case bfd_link_hash_common:
7539               return h->root.u.c.p->section;
7540
7541             default:
7542               break;
7543             }
7544         }
7545     }
7546   else
7547     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7548
7549   return NULL;
7550 }
7551
7552 /* Update the got entry reference counts for the section being removed.  */
7553
7554 bfd_boolean
7555 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
7556                              struct bfd_link_info *info ATTRIBUTE_UNUSED,
7557                              asection *sec ATTRIBUTE_UNUSED,
7558                              const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
7559 {
7560 #if 0
7561   Elf_Internal_Shdr *symtab_hdr;
7562   struct elf_link_hash_entry **sym_hashes;
7563   bfd_signed_vma *local_got_refcounts;
7564   const Elf_Internal_Rela *rel, *relend;
7565   unsigned long r_symndx;
7566   struct elf_link_hash_entry *h;
7567
7568   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7569   sym_hashes = elf_sym_hashes (abfd);
7570   local_got_refcounts = elf_local_got_refcounts (abfd);
7571
7572   relend = relocs + sec->reloc_count;
7573   for (rel = relocs; rel < relend; rel++)
7574     switch (ELF_R_TYPE (abfd, rel->r_info))
7575       {
7576       case R_MIPS_GOT16:
7577       case R_MIPS_CALL16:
7578       case R_MIPS_CALL_HI16:
7579       case R_MIPS_CALL_LO16:
7580       case R_MIPS_GOT_HI16:
7581       case R_MIPS_GOT_LO16:
7582       case R_MIPS_GOT_DISP:
7583       case R_MIPS_GOT_PAGE:
7584       case R_MIPS_GOT_OFST:
7585         /* ??? It would seem that the existing MIPS code does no sort
7586            of reference counting or whatnot on its GOT and PLT entries,
7587            so it is not possible to garbage collect them at this time.  */
7588         break;
7589
7590       default:
7591         break;
7592       }
7593 #endif
7594
7595   return TRUE;
7596 }
7597 \f
7598 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7599    hiding the old indirect symbol.  Process additional relocation
7600    information.  Also called for weakdefs, in which case we just let
7601    _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
7602
7603 void
7604 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
7605                                     struct elf_link_hash_entry *dir,
7606                                     struct elf_link_hash_entry *ind)
7607 {
7608   struct mips_elf_link_hash_entry *dirmips, *indmips;
7609
7610   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
7611
7612   if (ind->root.type != bfd_link_hash_indirect)
7613     return;
7614
7615   dirmips = (struct mips_elf_link_hash_entry *) dir;
7616   indmips = (struct mips_elf_link_hash_entry *) ind;
7617   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
7618   if (indmips->readonly_reloc)
7619     dirmips->readonly_reloc = TRUE;
7620   if (indmips->no_fn_stub)
7621     dirmips->no_fn_stub = TRUE;
7622 }
7623
7624 void
7625 _bfd_mips_elf_hide_symbol (struct bfd_link_info *info,
7626                            struct elf_link_hash_entry *entry,
7627                            bfd_boolean force_local)
7628 {
7629   bfd *dynobj;
7630   asection *got;
7631   struct mips_got_info *g;
7632   struct mips_elf_link_hash_entry *h;
7633
7634   h = (struct mips_elf_link_hash_entry *) entry;
7635   if (h->forced_local)
7636     return;
7637   h->forced_local = force_local;
7638
7639   dynobj = elf_hash_table (info)->dynobj;
7640   if (dynobj != NULL && force_local)
7641     {
7642       got = mips_elf_got_section (dynobj, FALSE);
7643       g = mips_elf_section_data (got)->u.got_info;
7644
7645       if (g->next)
7646         {
7647           struct mips_got_entry e;
7648           struct mips_got_info *gg = g;
7649
7650           /* Since we're turning what used to be a global symbol into a
7651              local one, bump up the number of local entries of each GOT
7652              that had an entry for it.  This will automatically decrease
7653              the number of global entries, since global_gotno is actually
7654              the upper limit of global entries.  */
7655           e.abfd = dynobj;
7656           e.symndx = -1;
7657           e.d.h = h;
7658
7659           for (g = g->next; g != gg; g = g->next)
7660             if (htab_find (g->got_entries, &e))
7661               {
7662                 BFD_ASSERT (g->global_gotno > 0);
7663                 g->local_gotno++;
7664                 g->global_gotno--;
7665               }
7666
7667           /* If this was a global symbol forced into the primary GOT, we
7668              no longer need an entry for it.  We can't release the entry
7669              at this point, but we must at least stop counting it as one
7670              of the symbols that required a forced got entry.  */
7671           if (h->root.got.offset == 2)
7672             {
7673               BFD_ASSERT (gg->assigned_gotno > 0);
7674               gg->assigned_gotno--;
7675             }
7676         }
7677       else if (g->global_gotno == 0 && g->global_gotsym == NULL)
7678         /* If we haven't got through GOT allocation yet, just bump up the
7679            number of local entries, as this symbol won't be counted as
7680            global.  */
7681         g->local_gotno++;
7682       else if (h->root.got.offset == 1)
7683         {
7684           /* If we're past non-multi-GOT allocation and this symbol had
7685              been marked for a global got entry, give it a local entry
7686              instead.  */
7687           BFD_ASSERT (g->global_gotno > 0);
7688           g->local_gotno++;
7689           g->global_gotno--;
7690         }
7691     }
7692
7693   _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
7694 }
7695 \f
7696 #define PDR_SIZE 32
7697
7698 bfd_boolean
7699 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
7700                             struct bfd_link_info *info)
7701 {
7702   asection *o;
7703   bfd_boolean ret = FALSE;
7704   unsigned char *tdata;
7705   size_t i, skip;
7706
7707   o = bfd_get_section_by_name (abfd, ".pdr");
7708   if (! o)
7709     return FALSE;
7710   if (o->_raw_size == 0)
7711     return FALSE;
7712   if (o->_raw_size % PDR_SIZE != 0)
7713     return FALSE;
7714   if (o->output_section != NULL
7715       && bfd_is_abs_section (o->output_section))
7716     return FALSE;
7717
7718   tdata = bfd_zmalloc (o->_raw_size / PDR_SIZE);
7719   if (! tdata)
7720     return FALSE;
7721
7722   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7723                                             info->keep_memory);
7724   if (!cookie->rels)
7725     {
7726       free (tdata);
7727       return FALSE;
7728     }
7729
7730   cookie->rel = cookie->rels;
7731   cookie->relend = cookie->rels + o->reloc_count;
7732
7733   for (i = 0, skip = 0; i < o->_raw_size / PDR_SIZE; i ++)
7734     {
7735       if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
7736         {
7737           tdata[i] = 1;
7738           skip ++;
7739         }
7740     }
7741
7742   if (skip != 0)
7743     {
7744       mips_elf_section_data (o)->u.tdata = tdata;
7745       o->_cooked_size = o->_raw_size - skip * PDR_SIZE;
7746       ret = TRUE;
7747     }
7748   else
7749     free (tdata);
7750
7751   if (! info->keep_memory)
7752     free (cookie->rels);
7753
7754   return ret;
7755 }
7756
7757 bfd_boolean
7758 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
7759 {
7760   if (strcmp (sec->name, ".pdr") == 0)
7761     return TRUE;
7762   return FALSE;
7763 }
7764
7765 bfd_boolean
7766 _bfd_mips_elf_write_section (bfd *output_bfd, asection *sec,
7767                              bfd_byte *contents)
7768 {
7769   bfd_byte *to, *from, *end;
7770   int i;
7771
7772   if (strcmp (sec->name, ".pdr") != 0)
7773     return FALSE;
7774
7775   if (mips_elf_section_data (sec)->u.tdata == NULL)
7776     return FALSE;
7777
7778   to = contents;
7779   end = contents + sec->_raw_size;
7780   for (from = contents, i = 0;
7781        from < end;
7782        from += PDR_SIZE, i++)
7783     {
7784       if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
7785         continue;
7786       if (to != from)
7787         memcpy (to, from, PDR_SIZE);
7788       to += PDR_SIZE;
7789     }
7790   bfd_set_section_contents (output_bfd, sec->output_section, contents,
7791                             sec->output_offset, sec->_cooked_size);
7792   return TRUE;
7793 }
7794 \f
7795 /* MIPS ELF uses a special find_nearest_line routine in order the
7796    handle the ECOFF debugging information.  */
7797
7798 struct mips_elf_find_line
7799 {
7800   struct ecoff_debug_info d;
7801   struct ecoff_find_line i;
7802 };
7803
7804 bfd_boolean
7805 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
7806                                  asymbol **symbols, bfd_vma offset,
7807                                  const char **filename_ptr,
7808                                  const char **functionname_ptr,
7809                                  unsigned int *line_ptr)
7810 {
7811   asection *msec;
7812
7813   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7814                                      filename_ptr, functionname_ptr,
7815                                      line_ptr))
7816     return TRUE;
7817
7818   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7819                                      filename_ptr, functionname_ptr,
7820                                      line_ptr, ABI_64_P (abfd) ? 8 : 0,
7821                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7822     return TRUE;
7823
7824   msec = bfd_get_section_by_name (abfd, ".mdebug");
7825   if (msec != NULL)
7826     {
7827       flagword origflags;
7828       struct mips_elf_find_line *fi;
7829       const struct ecoff_debug_swap * const swap =
7830         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
7831
7832       /* If we are called during a link, mips_elf_final_link may have
7833          cleared the SEC_HAS_CONTENTS field.  We force it back on here
7834          if appropriate (which it normally will be).  */
7835       origflags = msec->flags;
7836       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
7837         msec->flags |= SEC_HAS_CONTENTS;
7838
7839       fi = elf_tdata (abfd)->find_line_info;
7840       if (fi == NULL)
7841         {
7842           bfd_size_type external_fdr_size;
7843           char *fraw_src;
7844           char *fraw_end;
7845           struct fdr *fdr_ptr;
7846           bfd_size_type amt = sizeof (struct mips_elf_find_line);
7847
7848           fi = bfd_zalloc (abfd, amt);
7849           if (fi == NULL)
7850             {
7851               msec->flags = origflags;
7852               return FALSE;
7853             }
7854
7855           if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
7856             {
7857               msec->flags = origflags;
7858               return FALSE;
7859             }
7860
7861           /* Swap in the FDR information.  */
7862           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
7863           fi->d.fdr = bfd_alloc (abfd, amt);
7864           if (fi->d.fdr == NULL)
7865             {
7866               msec->flags = origflags;
7867               return FALSE;
7868             }
7869           external_fdr_size = swap->external_fdr_size;
7870           fdr_ptr = fi->d.fdr;
7871           fraw_src = (char *) fi->d.external_fdr;
7872           fraw_end = (fraw_src
7873                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
7874           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
7875             (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
7876
7877           elf_tdata (abfd)->find_line_info = fi;
7878
7879           /* Note that we don't bother to ever free this information.
7880              find_nearest_line is either called all the time, as in
7881              objdump -l, so the information should be saved, or it is
7882              rarely called, as in ld error messages, so the memory
7883              wasted is unimportant.  Still, it would probably be a
7884              good idea for free_cached_info to throw it away.  */
7885         }
7886
7887       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
7888                                   &fi->i, filename_ptr, functionname_ptr,
7889                                   line_ptr))
7890         {
7891           msec->flags = origflags;
7892           return TRUE;
7893         }
7894
7895       msec->flags = origflags;
7896     }
7897
7898   /* Fall back on the generic ELF find_nearest_line routine.  */
7899
7900   return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
7901                                      filename_ptr, functionname_ptr,
7902                                      line_ptr);
7903 }
7904 \f
7905 /* When are writing out the .options or .MIPS.options section,
7906    remember the bytes we are writing out, so that we can install the
7907    GP value in the section_processing routine.  */
7908
7909 bfd_boolean
7910 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
7911                                     const void *location,
7912                                     file_ptr offset, bfd_size_type count)
7913 {
7914   if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
7915     {
7916       bfd_byte *c;
7917
7918       if (elf_section_data (section) == NULL)
7919         {
7920           bfd_size_type amt = sizeof (struct bfd_elf_section_data);
7921           section->used_by_bfd = bfd_zalloc (abfd, amt);
7922           if (elf_section_data (section) == NULL)
7923             return FALSE;
7924         }
7925       c = mips_elf_section_data (section)->u.tdata;
7926       if (c == NULL)
7927         {
7928           bfd_size_type size;
7929
7930           if (section->_cooked_size != 0)
7931             size = section->_cooked_size;
7932           else
7933             size = section->_raw_size;
7934           c = bfd_zalloc (abfd, size);
7935           if (c == NULL)
7936             return FALSE;
7937           mips_elf_section_data (section)->u.tdata = c;
7938         }
7939
7940       memcpy (c + offset, location, count);
7941     }
7942
7943   return _bfd_elf_set_section_contents (abfd, section, location, offset,
7944                                         count);
7945 }
7946
7947 /* This is almost identical to bfd_generic_get_... except that some
7948    MIPS relocations need to be handled specially.  Sigh.  */
7949
7950 bfd_byte *
7951 _bfd_elf_mips_get_relocated_section_contents
7952   (bfd *abfd,
7953    struct bfd_link_info *link_info,
7954    struct bfd_link_order *link_order,
7955    bfd_byte *data,
7956    bfd_boolean relocatable,
7957    asymbol **symbols)
7958 {
7959   /* Get enough memory to hold the stuff */
7960   bfd *input_bfd = link_order->u.indirect.section->owner;
7961   asection *input_section = link_order->u.indirect.section;
7962
7963   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
7964   arelent **reloc_vector = NULL;
7965   long reloc_count;
7966
7967   if (reloc_size < 0)
7968     goto error_return;
7969
7970   reloc_vector = bfd_malloc (reloc_size);
7971   if (reloc_vector == NULL && reloc_size != 0)
7972     goto error_return;
7973
7974   /* read in the section */
7975   if (!bfd_get_section_contents (input_bfd, input_section, data, 0,
7976                                  input_section->_raw_size))
7977     goto error_return;
7978
7979   /* We're not relaxing the section, so just copy the size info */
7980   input_section->_cooked_size = input_section->_raw_size;
7981   input_section->reloc_done = TRUE;
7982
7983   reloc_count = bfd_canonicalize_reloc (input_bfd,
7984                                         input_section,
7985                                         reloc_vector,
7986                                         symbols);
7987   if (reloc_count < 0)
7988     goto error_return;
7989
7990   if (reloc_count > 0)
7991     {
7992       arelent **parent;
7993       /* for mips */
7994       int gp_found;
7995       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
7996
7997       {
7998         struct bfd_hash_entry *h;
7999         struct bfd_link_hash_entry *lh;
8000         /* Skip all this stuff if we aren't mixing formats.  */
8001         if (abfd && input_bfd
8002             && abfd->xvec == input_bfd->xvec)
8003           lh = 0;
8004         else
8005           {
8006             h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
8007             lh = (struct bfd_link_hash_entry *) h;
8008           }
8009       lookup:
8010         if (lh)
8011           {
8012             switch (lh->type)
8013               {
8014               case bfd_link_hash_undefined:
8015               case bfd_link_hash_undefweak:
8016               case bfd_link_hash_common:
8017                 gp_found = 0;
8018                 break;
8019               case bfd_link_hash_defined:
8020               case bfd_link_hash_defweak:
8021                 gp_found = 1;
8022                 gp = lh->u.def.value;
8023                 break;
8024               case bfd_link_hash_indirect:
8025               case bfd_link_hash_warning:
8026                 lh = lh->u.i.link;
8027                 /* @@FIXME  ignoring warning for now */
8028                 goto lookup;
8029               case bfd_link_hash_new:
8030               default:
8031                 abort ();
8032               }
8033           }
8034         else
8035           gp_found = 0;
8036       }
8037       /* end mips */
8038       for (parent = reloc_vector; *parent != NULL; parent++)
8039         {
8040           char *error_message = NULL;
8041           bfd_reloc_status_type r;
8042
8043           /* Specific to MIPS: Deal with relocation types that require
8044              knowing the gp of the output bfd.  */
8045           asymbol *sym = *(*parent)->sym_ptr_ptr;
8046           if (bfd_is_abs_section (sym->section) && abfd)
8047             {
8048               /* The special_function wouldn't get called anyway.  */
8049             }
8050           else if (!gp_found)
8051             {
8052               /* The gp isn't there; let the special function code
8053                  fall over on its own.  */
8054             }
8055           else if ((*parent)->howto->special_function
8056                    == _bfd_mips_elf32_gprel16_reloc)
8057             {
8058               /* bypass special_function call */
8059               r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
8060                                                  input_section, relocatable,
8061                                                  data, gp);
8062               goto skip_bfd_perform_relocation;
8063             }
8064           /* end mips specific stuff */
8065
8066           r = bfd_perform_relocation (input_bfd, *parent, data, input_section,
8067                                       relocatable ? abfd : NULL,
8068                                       &error_message);
8069         skip_bfd_perform_relocation:
8070
8071           if (relocatable)
8072             {
8073               asection *os = input_section->output_section;
8074
8075               /* A partial link, so keep the relocs */
8076               os->orelocation[os->reloc_count] = *parent;
8077               os->reloc_count++;
8078             }
8079
8080           if (r != bfd_reloc_ok)
8081             {
8082               switch (r)
8083                 {
8084                 case bfd_reloc_undefined:
8085                   if (!((*link_info->callbacks->undefined_symbol)
8086                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8087                          input_bfd, input_section, (*parent)->address,
8088                          TRUE)))
8089                     goto error_return;
8090                   break;
8091                 case bfd_reloc_dangerous:
8092                   BFD_ASSERT (error_message != NULL);
8093                   if (!((*link_info->callbacks->reloc_dangerous)
8094                         (link_info, error_message, input_bfd, input_section,
8095                          (*parent)->address)))
8096                     goto error_return;
8097                   break;
8098                 case bfd_reloc_overflow:
8099                   if (!((*link_info->callbacks->reloc_overflow)
8100                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8101                          (*parent)->howto->name, (*parent)->addend,
8102                          input_bfd, input_section, (*parent)->address)))
8103                     goto error_return;
8104                   break;
8105                 case bfd_reloc_outofrange:
8106                 default:
8107                   abort ();
8108                   break;
8109                 }
8110
8111             }
8112         }
8113     }
8114   if (reloc_vector != NULL)
8115     free (reloc_vector);
8116   return data;
8117
8118 error_return:
8119   if (reloc_vector != NULL)
8120     free (reloc_vector);
8121   return NULL;
8122 }
8123 \f
8124 /* Create a MIPS ELF linker hash table.  */
8125
8126 struct bfd_link_hash_table *
8127 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
8128 {
8129   struct mips_elf_link_hash_table *ret;
8130   bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
8131
8132   ret = bfd_malloc (amt);
8133   if (ret == NULL)
8134     return NULL;
8135
8136   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
8137                                        mips_elf_link_hash_newfunc))
8138     {
8139       free (ret);
8140       return NULL;
8141     }
8142
8143 #if 0
8144   /* We no longer use this.  */
8145   for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
8146     ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
8147 #endif
8148   ret->procedure_count = 0;
8149   ret->compact_rel_size = 0;
8150   ret->use_rld_obj_head = FALSE;
8151   ret->rld_value = 0;
8152   ret->mips16_stubs_seen = FALSE;
8153
8154   return &ret->root.root;
8155 }
8156 \f
8157 /* We need to use a special link routine to handle the .reginfo and
8158    the .mdebug sections.  We need to merge all instances of these
8159    sections together, not write them all out sequentially.  */
8160
8161 bfd_boolean
8162 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
8163 {
8164   asection **secpp;
8165   asection *o;
8166   struct bfd_link_order *p;
8167   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
8168   asection *rtproc_sec;
8169   Elf32_RegInfo reginfo;
8170   struct ecoff_debug_info debug;
8171   const struct ecoff_debug_swap *swap
8172     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
8173   HDRR *symhdr = &debug.symbolic_header;
8174   void *mdebug_handle = NULL;
8175   asection *s;
8176   EXTR esym;
8177   unsigned int i;
8178   bfd_size_type amt;
8179
8180   static const char * const secname[] =
8181   {
8182     ".text", ".init", ".fini", ".data",
8183     ".rodata", ".sdata", ".sbss", ".bss"
8184   };
8185   static const int sc[] =
8186   {
8187     scText, scInit, scFini, scData,
8188     scRData, scSData, scSBss, scBss
8189   };
8190
8191   /* We'd carefully arranged the dynamic symbol indices, and then the
8192      generic size_dynamic_sections renumbered them out from under us.
8193      Rather than trying somehow to prevent the renumbering, just do
8194      the sort again.  */
8195   if (elf_hash_table (info)->dynamic_sections_created)
8196     {
8197       bfd *dynobj;
8198       asection *got;
8199       struct mips_got_info *g;
8200
8201       /* When we resort, we must tell mips_elf_sort_hash_table what
8202          the lowest index it may use is.  That's the number of section
8203          symbols we're going to add.  The generic ELF linker only
8204          adds these symbols when building a shared object.  Note that
8205          we count the sections after (possibly) removing the .options
8206          section above.  */
8207       if (! mips_elf_sort_hash_table (info, (info->shared
8208                                              ? bfd_count_sections (abfd) + 1
8209                                              : 1)))
8210         return FALSE;
8211
8212       /* Make sure we didn't grow the global .got region.  */
8213       dynobj = elf_hash_table (info)->dynobj;
8214       got = mips_elf_got_section (dynobj, FALSE);
8215       g = mips_elf_section_data (got)->u.got_info;
8216
8217       if (g->global_gotsym != NULL)
8218         BFD_ASSERT ((elf_hash_table (info)->dynsymcount
8219                      - g->global_gotsym->dynindx)
8220                     <= g->global_gotno);
8221     }
8222
8223 #if 0
8224   /* We want to set the GP value for ld -r.  */
8225   /* On IRIX5, we omit the .options section.  On IRIX6, however, we
8226      include it, even though we don't process it quite right.  (Some
8227      entries are supposed to be merged.)  Empirically, we seem to be
8228      better off including it then not.  */
8229   if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
8230     for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8231       {
8232         if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8233           {
8234             for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8235               if (p->type == bfd_indirect_link_order)
8236                 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
8237             (*secpp)->link_order_head = NULL;
8238             bfd_section_list_remove (abfd, secpp);
8239             --abfd->section_count;
8240
8241             break;
8242           }
8243       }
8244
8245   /* We include .MIPS.options, even though we don't process it quite right.
8246      (Some entries are supposed to be merged.)  At IRIX6 empirically we seem
8247      to be better off including it than not.  */
8248   for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8249     {
8250       if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
8251         {
8252           for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8253             if (p->type == bfd_indirect_link_order)
8254               p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
8255           (*secpp)->link_order_head = NULL;
8256           bfd_section_list_remove (abfd, secpp);
8257           --abfd->section_count;
8258
8259           break;
8260         }
8261     }
8262 #endif
8263
8264   /* Get a value for the GP register.  */
8265   if (elf_gp (abfd) == 0)
8266     {
8267       struct bfd_link_hash_entry *h;
8268
8269       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
8270       if (h != NULL && h->type == bfd_link_hash_defined)
8271         elf_gp (abfd) = (h->u.def.value
8272                          + h->u.def.section->output_section->vma
8273                          + h->u.def.section->output_offset);
8274       else if (info->relocatable)
8275         {
8276           bfd_vma lo = MINUS_ONE;
8277
8278           /* Find the GP-relative section with the lowest offset.  */
8279           for (o = abfd->sections; o != NULL; o = o->next)
8280             if (o->vma < lo
8281                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
8282               lo = o->vma;
8283
8284           /* And calculate GP relative to that.  */
8285           elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
8286         }
8287       else
8288         {
8289           /* If the relocate_section function needs to do a reloc
8290              involving the GP value, it should make a reloc_dangerous
8291              callback to warn that GP is not defined.  */
8292         }
8293     }
8294
8295   /* Go through the sections and collect the .reginfo and .mdebug
8296      information.  */
8297   reginfo_sec = NULL;
8298   mdebug_sec = NULL;
8299   gptab_data_sec = NULL;
8300   gptab_bss_sec = NULL;
8301   for (o = abfd->sections; o != NULL; o = o->next)
8302     {
8303       if (strcmp (o->name, ".reginfo") == 0)
8304         {
8305           memset (&reginfo, 0, sizeof reginfo);
8306
8307           /* We have found the .reginfo section in the output file.
8308              Look through all the link_orders comprising it and merge
8309              the information together.  */
8310           for (p = o->link_order_head; p != NULL; p = p->next)
8311             {
8312               asection *input_section;
8313               bfd *input_bfd;
8314               Elf32_External_RegInfo ext;
8315               Elf32_RegInfo sub;
8316
8317               if (p->type != bfd_indirect_link_order)
8318                 {
8319                   if (p->type == bfd_data_link_order)
8320                     continue;
8321                   abort ();
8322                 }
8323
8324               input_section = p->u.indirect.section;
8325               input_bfd = input_section->owner;
8326
8327               /* The linker emulation code has probably clobbered the
8328                  size to be zero bytes.  */
8329               if (input_section->_raw_size == 0)
8330                 input_section->_raw_size = sizeof (Elf32_External_RegInfo);
8331
8332               if (! bfd_get_section_contents (input_bfd, input_section,
8333                                               &ext, 0, sizeof ext))
8334                 return FALSE;
8335
8336               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
8337
8338               reginfo.ri_gprmask |= sub.ri_gprmask;
8339               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
8340               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
8341               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
8342               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
8343
8344               /* ri_gp_value is set by the function
8345                  mips_elf32_section_processing when the section is
8346                  finally written out.  */
8347
8348               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8349                  elf_link_input_bfd ignores this section.  */
8350               input_section->flags &= ~SEC_HAS_CONTENTS;
8351             }
8352
8353           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
8354           BFD_ASSERT(o->_raw_size == sizeof (Elf32_External_RegInfo));
8355
8356           /* Skip this section later on (I don't think this currently
8357              matters, but someday it might).  */
8358           o->link_order_head = NULL;
8359
8360           reginfo_sec = o;
8361         }
8362
8363       if (strcmp (o->name, ".mdebug") == 0)
8364         {
8365           struct extsym_info einfo;
8366           bfd_vma last;
8367
8368           /* We have found the .mdebug section in the output file.
8369              Look through all the link_orders comprising it and merge
8370              the information together.  */
8371           symhdr->magic = swap->sym_magic;
8372           /* FIXME: What should the version stamp be?  */
8373           symhdr->vstamp = 0;
8374           symhdr->ilineMax = 0;
8375           symhdr->cbLine = 0;
8376           symhdr->idnMax = 0;
8377           symhdr->ipdMax = 0;
8378           symhdr->isymMax = 0;
8379           symhdr->ioptMax = 0;
8380           symhdr->iauxMax = 0;
8381           symhdr->issMax = 0;
8382           symhdr->issExtMax = 0;
8383           symhdr->ifdMax = 0;
8384           symhdr->crfd = 0;
8385           symhdr->iextMax = 0;
8386
8387           /* We accumulate the debugging information itself in the
8388              debug_info structure.  */
8389           debug.line = NULL;
8390           debug.external_dnr = NULL;
8391           debug.external_pdr = NULL;
8392           debug.external_sym = NULL;
8393           debug.external_opt = NULL;
8394           debug.external_aux = NULL;
8395           debug.ss = NULL;
8396           debug.ssext = debug.ssext_end = NULL;
8397           debug.external_fdr = NULL;
8398           debug.external_rfd = NULL;
8399           debug.external_ext = debug.external_ext_end = NULL;
8400
8401           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
8402           if (mdebug_handle == NULL)
8403             return FALSE;
8404
8405           esym.jmptbl = 0;
8406           esym.cobol_main = 0;
8407           esym.weakext = 0;
8408           esym.reserved = 0;
8409           esym.ifd = ifdNil;
8410           esym.asym.iss = issNil;
8411           esym.asym.st = stLocal;
8412           esym.asym.reserved = 0;
8413           esym.asym.index = indexNil;
8414           last = 0;
8415           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
8416             {
8417               esym.asym.sc = sc[i];
8418               s = bfd_get_section_by_name (abfd, secname[i]);
8419               if (s != NULL)
8420                 {
8421                   esym.asym.value = s->vma;
8422                   last = s->vma + s->_raw_size;
8423                 }
8424               else
8425                 esym.asym.value = last;
8426               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
8427                                                  secname[i], &esym))
8428                 return FALSE;
8429             }
8430
8431           for (p = o->link_order_head; p != NULL; p = p->next)
8432             {
8433               asection *input_section;
8434               bfd *input_bfd;
8435               const struct ecoff_debug_swap *input_swap;
8436               struct ecoff_debug_info input_debug;
8437               char *eraw_src;
8438               char *eraw_end;
8439
8440               if (p->type != bfd_indirect_link_order)
8441                 {
8442                   if (p->type == bfd_data_link_order)
8443                     continue;
8444                   abort ();
8445                 }
8446
8447               input_section = p->u.indirect.section;
8448               input_bfd = input_section->owner;
8449
8450               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
8451                   || (get_elf_backend_data (input_bfd)
8452                       ->elf_backend_ecoff_debug_swap) == NULL)
8453                 {
8454                   /* I don't know what a non MIPS ELF bfd would be
8455                      doing with a .mdebug section, but I don't really
8456                      want to deal with it.  */
8457                   continue;
8458                 }
8459
8460               input_swap = (get_elf_backend_data (input_bfd)
8461                             ->elf_backend_ecoff_debug_swap);
8462
8463               BFD_ASSERT (p->size == input_section->_raw_size);
8464
8465               /* The ECOFF linking code expects that we have already
8466                  read in the debugging information and set up an
8467                  ecoff_debug_info structure, so we do that now.  */
8468               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
8469                                                    &input_debug))
8470                 return FALSE;
8471
8472               if (! (bfd_ecoff_debug_accumulate
8473                      (mdebug_handle, abfd, &debug, swap, input_bfd,
8474                       &input_debug, input_swap, info)))
8475                 return FALSE;
8476
8477               /* Loop through the external symbols.  For each one with
8478                  interesting information, try to find the symbol in
8479                  the linker global hash table and save the information
8480                  for the output external symbols.  */
8481               eraw_src = input_debug.external_ext;
8482               eraw_end = (eraw_src
8483                           + (input_debug.symbolic_header.iextMax
8484                              * input_swap->external_ext_size));
8485               for (;
8486                    eraw_src < eraw_end;
8487                    eraw_src += input_swap->external_ext_size)
8488                 {
8489                   EXTR ext;
8490                   const char *name;
8491                   struct mips_elf_link_hash_entry *h;
8492
8493                   (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
8494                   if (ext.asym.sc == scNil
8495                       || ext.asym.sc == scUndefined
8496                       || ext.asym.sc == scSUndefined)
8497                     continue;
8498
8499                   name = input_debug.ssext + ext.asym.iss;
8500                   h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
8501                                                  name, FALSE, FALSE, TRUE);
8502                   if (h == NULL || h->esym.ifd != -2)
8503                     continue;
8504
8505                   if (ext.ifd != -1)
8506                     {
8507                       BFD_ASSERT (ext.ifd
8508                                   < input_debug.symbolic_header.ifdMax);
8509                       ext.ifd = input_debug.ifdmap[ext.ifd];
8510                     }
8511
8512                   h->esym = ext;
8513                 }
8514
8515               /* Free up the information we just read.  */
8516               free (input_debug.line);
8517               free (input_debug.external_dnr);
8518               free (input_debug.external_pdr);
8519               free (input_debug.external_sym);
8520               free (input_debug.external_opt);
8521               free (input_debug.external_aux);
8522               free (input_debug.ss);
8523               free (input_debug.ssext);
8524               free (input_debug.external_fdr);
8525               free (input_debug.external_rfd);
8526               free (input_debug.external_ext);
8527
8528               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8529                  elf_link_input_bfd ignores this section.  */
8530               input_section->flags &= ~SEC_HAS_CONTENTS;
8531             }
8532
8533           if (SGI_COMPAT (abfd) && info->shared)
8534             {
8535               /* Create .rtproc section.  */
8536               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8537               if (rtproc_sec == NULL)
8538                 {
8539                   flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
8540                                     | SEC_LINKER_CREATED | SEC_READONLY);
8541
8542                   rtproc_sec = bfd_make_section (abfd, ".rtproc");
8543                   if (rtproc_sec == NULL
8544                       || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
8545                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
8546                     return FALSE;
8547                 }
8548
8549               if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
8550                                                      info, rtproc_sec,
8551                                                      &debug))
8552                 return FALSE;
8553             }
8554
8555           /* Build the external symbol information.  */
8556           einfo.abfd = abfd;
8557           einfo.info = info;
8558           einfo.debug = &debug;
8559           einfo.swap = swap;
8560           einfo.failed = FALSE;
8561           mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8562                                        mips_elf_output_extsym, &einfo);
8563           if (einfo.failed)
8564             return FALSE;
8565
8566           /* Set the size of the .mdebug section.  */
8567           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
8568
8569           /* Skip this section later on (I don't think this currently
8570              matters, but someday it might).  */
8571           o->link_order_head = NULL;
8572
8573           mdebug_sec = o;
8574         }
8575
8576       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
8577         {
8578           const char *subname;
8579           unsigned int c;
8580           Elf32_gptab *tab;
8581           Elf32_External_gptab *ext_tab;
8582           unsigned int j;
8583
8584           /* The .gptab.sdata and .gptab.sbss sections hold
8585              information describing how the small data area would
8586              change depending upon the -G switch.  These sections
8587              not used in executables files.  */
8588           if (! info->relocatable)
8589             {
8590               for (p = o->link_order_head; p != NULL; p = p->next)
8591                 {
8592                   asection *input_section;
8593
8594                   if (p->type != bfd_indirect_link_order)
8595                     {
8596                       if (p->type == bfd_data_link_order)
8597                         continue;
8598                       abort ();
8599                     }
8600
8601                   input_section = p->u.indirect.section;
8602
8603                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
8604                      elf_link_input_bfd ignores this section.  */
8605                   input_section->flags &= ~SEC_HAS_CONTENTS;
8606                 }
8607
8608               /* Skip this section later on (I don't think this
8609                  currently matters, but someday it might).  */
8610               o->link_order_head = NULL;
8611
8612               /* Really remove the section.  */
8613               for (secpp = &abfd->sections;
8614                    *secpp != o;
8615                    secpp = &(*secpp)->next)
8616                 ;
8617               bfd_section_list_remove (abfd, secpp);
8618               --abfd->section_count;
8619
8620               continue;
8621             }
8622
8623           /* There is one gptab for initialized data, and one for
8624              uninitialized data.  */
8625           if (strcmp (o->name, ".gptab.sdata") == 0)
8626             gptab_data_sec = o;
8627           else if (strcmp (o->name, ".gptab.sbss") == 0)
8628             gptab_bss_sec = o;
8629           else
8630             {
8631               (*_bfd_error_handler)
8632                 (_("%s: illegal section name `%s'"),
8633                  bfd_get_filename (abfd), o->name);
8634               bfd_set_error (bfd_error_nonrepresentable_section);
8635               return FALSE;
8636             }
8637
8638           /* The linker script always combines .gptab.data and
8639              .gptab.sdata into .gptab.sdata, and likewise for
8640              .gptab.bss and .gptab.sbss.  It is possible that there is
8641              no .sdata or .sbss section in the output file, in which
8642              case we must change the name of the output section.  */
8643           subname = o->name + sizeof ".gptab" - 1;
8644           if (bfd_get_section_by_name (abfd, subname) == NULL)
8645             {
8646               if (o == gptab_data_sec)
8647                 o->name = ".gptab.data";
8648               else
8649                 o->name = ".gptab.bss";
8650               subname = o->name + sizeof ".gptab" - 1;
8651               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
8652             }
8653
8654           /* Set up the first entry.  */
8655           c = 1;
8656           amt = c * sizeof (Elf32_gptab);
8657           tab = bfd_malloc (amt);
8658           if (tab == NULL)
8659             return FALSE;
8660           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
8661           tab[0].gt_header.gt_unused = 0;
8662
8663           /* Combine the input sections.  */
8664           for (p = o->link_order_head; p != NULL; p = p->next)
8665             {
8666               asection *input_section;
8667               bfd *input_bfd;
8668               bfd_size_type size;
8669               unsigned long last;
8670               bfd_size_type gpentry;
8671
8672               if (p->type != bfd_indirect_link_order)
8673                 {
8674                   if (p->type == bfd_data_link_order)
8675                     continue;
8676                   abort ();
8677                 }
8678
8679               input_section = p->u.indirect.section;
8680               input_bfd = input_section->owner;
8681
8682               /* Combine the gptab entries for this input section one
8683                  by one.  We know that the input gptab entries are
8684                  sorted by ascending -G value.  */
8685               size = bfd_section_size (input_bfd, input_section);
8686               last = 0;
8687               for (gpentry = sizeof (Elf32_External_gptab);
8688                    gpentry < size;
8689                    gpentry += sizeof (Elf32_External_gptab))
8690                 {
8691                   Elf32_External_gptab ext_gptab;
8692                   Elf32_gptab int_gptab;
8693                   unsigned long val;
8694                   unsigned long add;
8695                   bfd_boolean exact;
8696                   unsigned int look;
8697
8698                   if (! (bfd_get_section_contents
8699                          (input_bfd, input_section, &ext_gptab, gpentry,
8700                           sizeof (Elf32_External_gptab))))
8701                     {
8702                       free (tab);
8703                       return FALSE;
8704                     }
8705
8706                   bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
8707                                                 &int_gptab);
8708                   val = int_gptab.gt_entry.gt_g_value;
8709                   add = int_gptab.gt_entry.gt_bytes - last;
8710
8711                   exact = FALSE;
8712                   for (look = 1; look < c; look++)
8713                     {
8714                       if (tab[look].gt_entry.gt_g_value >= val)
8715                         tab[look].gt_entry.gt_bytes += add;
8716
8717                       if (tab[look].gt_entry.gt_g_value == val)
8718                         exact = TRUE;
8719                     }
8720
8721                   if (! exact)
8722                     {
8723                       Elf32_gptab *new_tab;
8724                       unsigned int max;
8725
8726                       /* We need a new table entry.  */
8727                       amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
8728                       new_tab = bfd_realloc (tab, amt);
8729                       if (new_tab == NULL)
8730                         {
8731                           free (tab);
8732                           return FALSE;
8733                         }
8734                       tab = new_tab;
8735                       tab[c].gt_entry.gt_g_value = val;
8736                       tab[c].gt_entry.gt_bytes = add;
8737
8738                       /* Merge in the size for the next smallest -G
8739                          value, since that will be implied by this new
8740                          value.  */
8741                       max = 0;
8742                       for (look = 1; look < c; look++)
8743                         {
8744                           if (tab[look].gt_entry.gt_g_value < val
8745                               && (max == 0
8746                                   || (tab[look].gt_entry.gt_g_value
8747                                       > tab[max].gt_entry.gt_g_value)))
8748                             max = look;
8749                         }
8750                       if (max != 0)
8751                         tab[c].gt_entry.gt_bytes +=
8752                           tab[max].gt_entry.gt_bytes;
8753
8754                       ++c;
8755                     }
8756
8757                   last = int_gptab.gt_entry.gt_bytes;
8758                 }
8759
8760               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8761                  elf_link_input_bfd ignores this section.  */
8762               input_section->flags &= ~SEC_HAS_CONTENTS;
8763             }
8764
8765           /* The table must be sorted by -G value.  */
8766           if (c > 2)
8767             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
8768
8769           /* Swap out the table.  */
8770           amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
8771           ext_tab = bfd_alloc (abfd, amt);
8772           if (ext_tab == NULL)
8773             {
8774               free (tab);
8775               return FALSE;
8776             }
8777
8778           for (j = 0; j < c; j++)
8779             bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
8780           free (tab);
8781
8782           o->_raw_size = c * sizeof (Elf32_External_gptab);
8783           o->contents = (bfd_byte *) ext_tab;
8784
8785           /* Skip this section later on (I don't think this currently
8786              matters, but someday it might).  */
8787           o->link_order_head = NULL;
8788         }
8789     }
8790
8791   /* Invoke the regular ELF backend linker to do all the work.  */
8792   if (!bfd_elf_final_link (abfd, info))
8793     return FALSE;
8794
8795   /* Now write out the computed sections.  */
8796
8797   if (reginfo_sec != NULL)
8798     {
8799       Elf32_External_RegInfo ext;
8800
8801       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
8802       if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
8803         return FALSE;
8804     }
8805
8806   if (mdebug_sec != NULL)
8807     {
8808       BFD_ASSERT (abfd->output_has_begun);
8809       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
8810                                                swap, info,
8811                                                mdebug_sec->filepos))
8812         return FALSE;
8813
8814       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
8815     }
8816
8817   if (gptab_data_sec != NULL)
8818     {
8819       if (! bfd_set_section_contents (abfd, gptab_data_sec,
8820                                       gptab_data_sec->contents,
8821                                       0, gptab_data_sec->_raw_size))
8822         return FALSE;
8823     }
8824
8825   if (gptab_bss_sec != NULL)
8826     {
8827       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
8828                                       gptab_bss_sec->contents,
8829                                       0, gptab_bss_sec->_raw_size))
8830         return FALSE;
8831     }
8832
8833   if (SGI_COMPAT (abfd))
8834     {
8835       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8836       if (rtproc_sec != NULL)
8837         {
8838           if (! bfd_set_section_contents (abfd, rtproc_sec,
8839                                           rtproc_sec->contents,
8840                                           0, rtproc_sec->_raw_size))
8841             return FALSE;
8842         }
8843     }
8844
8845   return TRUE;
8846 }
8847 \f
8848 /* Structure for saying that BFD machine EXTENSION extends BASE.  */
8849
8850 struct mips_mach_extension {
8851   unsigned long extension, base;
8852 };
8853
8854
8855 /* An array describing how BFD machines relate to one another.  The entries
8856    are ordered topologically with MIPS I extensions listed last.  */
8857
8858 static const struct mips_mach_extension mips_mach_extensions[] = {
8859   /* MIPS64 extensions.  */
8860   { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
8861   { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
8862
8863   /* MIPS V extensions.  */
8864   { bfd_mach_mipsisa64, bfd_mach_mips5 },
8865
8866   /* R10000 extensions.  */
8867   { bfd_mach_mips12000, bfd_mach_mips10000 },
8868
8869   /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
8870      vr5400 ISA, but doesn't include the multimedia stuff.  It seems
8871      better to allow vr5400 and vr5500 code to be merged anyway, since
8872      many libraries will just use the core ISA.  Perhaps we could add
8873      some sort of ASE flag if this ever proves a problem.  */
8874   { bfd_mach_mips5500, bfd_mach_mips5400 },
8875   { bfd_mach_mips5400, bfd_mach_mips5000 },
8876
8877   /* MIPS IV extensions.  */
8878   { bfd_mach_mips5, bfd_mach_mips8000 },
8879   { bfd_mach_mips10000, bfd_mach_mips8000 },
8880   { bfd_mach_mips5000, bfd_mach_mips8000 },
8881   { bfd_mach_mips7000, bfd_mach_mips8000 },
8882
8883   /* VR4100 extensions.  */
8884   { bfd_mach_mips4120, bfd_mach_mips4100 },
8885   { bfd_mach_mips4111, bfd_mach_mips4100 },
8886
8887   /* MIPS III extensions.  */
8888   { bfd_mach_mips8000, bfd_mach_mips4000 },
8889   { bfd_mach_mips4650, bfd_mach_mips4000 },
8890   { bfd_mach_mips4600, bfd_mach_mips4000 },
8891   { bfd_mach_mips4400, bfd_mach_mips4000 },
8892   { bfd_mach_mips4300, bfd_mach_mips4000 },
8893   { bfd_mach_mips4100, bfd_mach_mips4000 },
8894   { bfd_mach_mips4010, bfd_mach_mips4000 },
8895
8896   /* MIPS32 extensions.  */
8897   { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
8898
8899   /* MIPS II extensions.  */
8900   { bfd_mach_mips4000, bfd_mach_mips6000 },
8901   { bfd_mach_mipsisa32, bfd_mach_mips6000 },
8902
8903   /* MIPS I extensions.  */
8904   { bfd_mach_mips6000, bfd_mach_mips3000 },
8905   { bfd_mach_mips3900, bfd_mach_mips3000 }
8906 };
8907
8908
8909 /* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
8910
8911 static bfd_boolean
8912 mips_mach_extends_p (unsigned long base, unsigned long extension)
8913 {
8914   size_t i;
8915
8916   for (i = 0; extension != base && i < ARRAY_SIZE (mips_mach_extensions); i++)
8917     if (extension == mips_mach_extensions[i].extension)
8918       extension = mips_mach_extensions[i].base;
8919
8920   return extension == base;
8921 }
8922
8923
8924 /* Return true if the given ELF header flags describe a 32-bit binary.  */
8925
8926 static bfd_boolean
8927 mips_32bit_flags_p (flagword flags)
8928 {
8929   return ((flags & EF_MIPS_32BITMODE) != 0
8930           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
8931           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
8932           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
8933           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
8934           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
8935           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
8936 }
8937
8938
8939 /* Merge backend specific data from an object file to the output
8940    object file when linking.  */
8941
8942 bfd_boolean
8943 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
8944 {
8945   flagword old_flags;
8946   flagword new_flags;
8947   bfd_boolean ok;
8948   bfd_boolean null_input_bfd = TRUE;
8949   asection *sec;
8950
8951   /* Check if we have the same endianess */
8952   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
8953     {
8954       (*_bfd_error_handler)
8955         (_("%s: endianness incompatible with that of the selected emulation"),
8956          bfd_archive_filename (ibfd));
8957       return FALSE;
8958     }
8959
8960   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
8961       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
8962     return TRUE;
8963
8964   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
8965     {
8966       (*_bfd_error_handler)
8967         (_("%s: ABI is incompatible with that of the selected emulation"),
8968          bfd_archive_filename (ibfd));
8969       return FALSE;
8970     }
8971
8972   new_flags = elf_elfheader (ibfd)->e_flags;
8973   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
8974   old_flags = elf_elfheader (obfd)->e_flags;
8975
8976   if (! elf_flags_init (obfd))
8977     {
8978       elf_flags_init (obfd) = TRUE;
8979       elf_elfheader (obfd)->e_flags = new_flags;
8980       elf_elfheader (obfd)->e_ident[EI_CLASS]
8981         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
8982
8983       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
8984           && bfd_get_arch_info (obfd)->the_default)
8985         {
8986           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
8987                                    bfd_get_mach (ibfd)))
8988             return FALSE;
8989         }
8990
8991       return TRUE;
8992     }
8993
8994   /* Check flag compatibility.  */
8995
8996   new_flags &= ~EF_MIPS_NOREORDER;
8997   old_flags &= ~EF_MIPS_NOREORDER;
8998
8999   /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
9000      doesn't seem to matter.  */
9001   new_flags &= ~EF_MIPS_XGOT;
9002   old_flags &= ~EF_MIPS_XGOT;
9003
9004   /* MIPSpro generates ucode info in n64 objects.  Again, we should
9005      just be able to ignore this.  */
9006   new_flags &= ~EF_MIPS_UCODE;
9007   old_flags &= ~EF_MIPS_UCODE;
9008
9009   if (new_flags == old_flags)
9010     return TRUE;
9011
9012   /* Check to see if the input BFD actually contains any sections.
9013      If not, its flags may not have been initialised either, but it cannot
9014      actually cause any incompatibility.  */
9015   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9016     {
9017       /* Ignore synthetic sections and empty .text, .data and .bss sections
9018           which are automatically generated by gas.  */
9019       if (strcmp (sec->name, ".reginfo")
9020           && strcmp (sec->name, ".mdebug")
9021           && (sec->_raw_size != 0
9022               || (strcmp (sec->name, ".text")
9023                   && strcmp (sec->name, ".data")
9024                   && strcmp (sec->name, ".bss"))))
9025         {
9026           null_input_bfd = FALSE;
9027           break;
9028         }
9029     }
9030   if (null_input_bfd)
9031     return TRUE;
9032
9033   ok = TRUE;
9034
9035   if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
9036       != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
9037     {
9038       (*_bfd_error_handler)
9039         (_("%s: warning: linking PIC files with non-PIC files"),
9040          bfd_archive_filename (ibfd));
9041       ok = TRUE;
9042     }
9043
9044   if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
9045     elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
9046   if (! (new_flags & EF_MIPS_PIC))
9047     elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
9048
9049   new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9050   old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9051
9052   /* Compare the ISAs.  */
9053   if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
9054     {
9055       (*_bfd_error_handler)
9056         (_("%s: linking 32-bit code with 64-bit code"),
9057          bfd_archive_filename (ibfd));
9058       ok = FALSE;
9059     }
9060   else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
9061     {
9062       /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
9063       if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
9064         {
9065           /* Copy the architecture info from IBFD to OBFD.  Also copy
9066              the 32-bit flag (if set) so that we continue to recognise
9067              OBFD as a 32-bit binary.  */
9068           bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
9069           elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
9070           elf_elfheader (obfd)->e_flags
9071             |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9072
9073           /* Copy across the ABI flags if OBFD doesn't use them
9074              and if that was what caused us to treat IBFD as 32-bit.  */
9075           if ((old_flags & EF_MIPS_ABI) == 0
9076               && mips_32bit_flags_p (new_flags)
9077               && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
9078             elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
9079         }
9080       else
9081         {
9082           /* The ISAs aren't compatible.  */
9083           (*_bfd_error_handler)
9084             (_("%s: linking %s module with previous %s modules"),
9085              bfd_archive_filename (ibfd),
9086              bfd_printable_name (ibfd),
9087              bfd_printable_name (obfd));
9088           ok = FALSE;
9089         }
9090     }
9091
9092   new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9093   old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9094
9095   /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
9096      does set EI_CLASS differently from any 32-bit ABI.  */
9097   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
9098       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9099           != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9100     {
9101       /* Only error if both are set (to different values).  */
9102       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
9103           || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9104               != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9105         {
9106           (*_bfd_error_handler)
9107             (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9108              bfd_archive_filename (ibfd),
9109              elf_mips_abi_name (ibfd),
9110              elf_mips_abi_name (obfd));
9111           ok = FALSE;
9112         }
9113       new_flags &= ~EF_MIPS_ABI;
9114       old_flags &= ~EF_MIPS_ABI;
9115     }
9116
9117   /* For now, allow arbitrary mixing of ASEs (retain the union).  */
9118   if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
9119     {
9120       elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
9121
9122       new_flags &= ~ EF_MIPS_ARCH_ASE;
9123       old_flags &= ~ EF_MIPS_ARCH_ASE;
9124     }
9125
9126   /* Warn about any other mismatches */
9127   if (new_flags != old_flags)
9128     {
9129       (*_bfd_error_handler)
9130         (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9131          bfd_archive_filename (ibfd), (unsigned long) new_flags,
9132          (unsigned long) old_flags);
9133       ok = FALSE;
9134     }
9135
9136   if (! ok)
9137     {
9138       bfd_set_error (bfd_error_bad_value);
9139       return FALSE;
9140     }
9141
9142   return TRUE;
9143 }
9144
9145 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
9146
9147 bfd_boolean
9148 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
9149 {
9150   BFD_ASSERT (!elf_flags_init (abfd)
9151               || elf_elfheader (abfd)->e_flags == flags);
9152
9153   elf_elfheader (abfd)->e_flags = flags;
9154   elf_flags_init (abfd) = TRUE;
9155   return TRUE;
9156 }
9157
9158 bfd_boolean
9159 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
9160 {
9161   FILE *file = ptr;
9162
9163   BFD_ASSERT (abfd != NULL && ptr != NULL);
9164
9165   /* Print normal ELF private data.  */
9166   _bfd_elf_print_private_bfd_data (abfd, ptr);
9167
9168   /* xgettext:c-format */
9169   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
9170
9171   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
9172     fprintf (file, _(" [abi=O32]"));
9173   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
9174     fprintf (file, _(" [abi=O64]"));
9175   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
9176     fprintf (file, _(" [abi=EABI32]"));
9177   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
9178     fprintf (file, _(" [abi=EABI64]"));
9179   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
9180     fprintf (file, _(" [abi unknown]"));
9181   else if (ABI_N32_P (abfd))
9182     fprintf (file, _(" [abi=N32]"));
9183   else if (ABI_64_P (abfd))
9184     fprintf (file, _(" [abi=64]"));
9185   else
9186     fprintf (file, _(" [no abi set]"));
9187
9188   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
9189     fprintf (file, _(" [mips1]"));
9190   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
9191     fprintf (file, _(" [mips2]"));
9192   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
9193     fprintf (file, _(" [mips3]"));
9194   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
9195     fprintf (file, _(" [mips4]"));
9196   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
9197     fprintf (file, _(" [mips5]"));
9198   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
9199     fprintf (file, _(" [mips32]"));
9200   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
9201     fprintf (file, _(" [mips64]"));
9202   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
9203     fprintf (file, _(" [mips32r2]"));
9204   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
9205     fprintf (file, _(" [mips64r2]"));
9206   else
9207     fprintf (file, _(" [unknown ISA]"));
9208
9209   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
9210     fprintf (file, _(" [mdmx]"));
9211
9212   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
9213     fprintf (file, _(" [mips16]"));
9214
9215   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
9216     fprintf (file, _(" [32bitmode]"));
9217   else
9218     fprintf (file, _(" [not 32bitmode]"));
9219
9220   fputc ('\n', file);
9221
9222   return TRUE;
9223 }
9224
9225 struct bfd_elf_special_section const _bfd_mips_elf_special_sections[]=
9226 {
9227   { ".sdata",  6, -2, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9228   { ".sbss",   5, -2, SHT_NOBITS,     SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9229   { ".lit4",   5,  0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9230   { ".lit8",   5,  0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9231   { ".ucode",  6,  0, SHT_MIPS_UCODE, 0 },
9232   { ".mdebug", 7,  0, SHT_MIPS_DEBUG, 0 },
9233   { NULL,      0,  0, 0,              0 }
9234 };