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