bfd/elfxx-mips.c

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