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